diff --git a/.npmignore b/.npmignore
index 3af34bded4a..d295e9bbd77 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1,5 +1,6 @@
 built
 doc
+lib/README.md
 scripts
 src
 tests
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2e2c28590c2..68d88854849 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -32,6 +32,19 @@ Your pull request should:
 * Follow the code conventions descriped in [Coding guidelines](https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines)
 * To avoid line ending issues, set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration
 
+## Contributing `lib.d.ts` fixes
+ 
+The library sources are in: [src/lib](https://github.com/Microsoft/TypeScript/tree/master/src/lib)
+
+To build the library files, run
+```Shell
+jake lib
+```
+
+#### `src/lib/dom.generated.d.ts` and `src/lib/webworker.generated.d.ts`
+
+These two files represent the DOM typings and are auto-generated. To make any modifications to them, please submit a PR to  https://github.com/Microsoft/TSJS-lib-generator
+
 ## Running the Tests
 
 To run all tests, invoke the `runtests` target using jake:
diff --git a/Jakefile.js b/Jakefile.js
index 6a1ac19f456..14bf047cf21 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -147,7 +147,8 @@ var harnessSources = harnessCoreSources.concat([
     "transpile.ts",
     "reuseProgramStructure.ts",
     "cachingInServerLSHost.ts",
-    "moduleResolution.ts"
+    "moduleResolution.ts",
+    "tsconfigParsing.ts"
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
@@ -227,7 +228,7 @@ var builtLocalCompiler = path.join(builtLocalDirectory, compilerFilename);
 function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOutFile, generateDeclarations, outDir, preserveConstEnums, keepComments, noResolve, stripInternal, callback) {
     file(outFile, prereqs, function() {
         var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
-        var options = "--module commonjs --noImplicitAny --noEmitOnError";
+        var options = "--module commonjs --noImplicitAny --noEmitOnError --pretty";
 
         // Keep comments when specifically requested
         // or when in debug mode.
@@ -858,6 +859,7 @@ var tslintRuleDir = "scripts/tslint";
 var tslintRules = ([
     "nextLineRule",
     "noNullRule",
+    "preferConstRule",
     "booleanTriviaRule",
     "typeOperatorSpacingRule"
 ]);
diff --git a/lib/README.md b/lib/README.md
new file mode 100644
index 00000000000..b2837989505
--- /dev/null
+++ b/lib/README.md
@@ -0,0 +1,4 @@
+# Read this!
+
+These files are not meant to be edited by hand.
+If you need to make modifications, the respective files should be changed within the repository's top-level `src` directory.
\ No newline at end of file
diff --git a/lib/tsc.js b/lib/tsc.js
index 511fc67c0aa..bbbcedf0f47 100644
--- a/lib/tsc.js
+++ b/lib/tsc.js
@@ -49,40 +49,49 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
-    function createFileMap(getCanonicalFileName) {
+    function createFileMap(keyMapper) {
         var files = {};
         return {
             get: get,
             set: set,
             contains: contains,
             remove: remove,
-            clear: clear,
-            forEachValue: forEachValueInMap
+            forEachValue: forEachValueInMap,
+            clear: clear
         };
-        function set(fileName, value) {
-            files[normalizeKey(fileName)] = value;
-        }
-        function get(fileName) {
-            return files[normalizeKey(fileName)];
-        }
-        function contains(fileName) {
-            return hasProperty(files, normalizeKey(fileName));
-        }
-        function remove(fileName) {
-            var key = normalizeKey(fileName);
-            delete files[key];
-        }
         function forEachValueInMap(f) {
-            forEachValue(files, f);
+            for (var key in files) {
+                f(key, files[key]);
+            }
         }
-        function normalizeKey(key) {
-            return getCanonicalFileName(normalizeSlashes(key));
+        function get(path) {
+            return files[toKey(path)];
+        }
+        function set(path, value) {
+            files[toKey(path)] = value;
+        }
+        function contains(path) {
+            return hasProperty(files, toKey(path));
+        }
+        function remove(path) {
+            var key = toKey(path);
+            delete files[key];
         }
         function clear() {
             files = {};
         }
+        function toKey(path) {
+            return keyMapper ? keyMapper(path) : path;
+        }
     }
     ts.createFileMap = createFileMap;
+    function toPath(fileName, basePath, getCanonicalFileName) {
+        var nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return getCanonicalFileName(nonCanonicalizedPath);
+    }
+    ts.toPath = toPath;
     function forEach(array, callback) {
         if (array) {
             for (var i = 0, len = array.length; i < len; i++) {
@@ -97,8 +106,8 @@ var ts;
     ts.forEach = forEach;
     function contains(array, value) {
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+                var v = array_1[_i];
                 if (v === value) {
                     return true;
                 }
@@ -121,8 +130,8 @@ var ts;
     function countWhere(array, predicate) {
         var count = 0;
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
+                var v = array_2[_i];
                 if (predicate(v)) {
                     count++;
                 }
@@ -135,8 +144,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
+                var item = array_3[_i];
                 if (f(item)) {
                     result.push(item);
                 }
@@ -149,8 +158,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
+                var v = array_4[_i];
                 result.push(f(v));
             }
         }
@@ -169,8 +178,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
+                var item = array_5[_i];
                 if (!contains(result, item)) {
                     result.push(item);
                 }
@@ -181,8 +190,8 @@ var ts;
     ts.deduplicate = deduplicate;
     function sum(array, prop) {
         var result = 0;
-        for (var _i = 0; _i < array.length; _i++) {
-            var v = array[_i];
+        for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
+            var v = array_6[_i];
             result += v[prop];
         }
         return result;
@@ -190,8 +199,8 @@ var ts;
     ts.sum = sum;
     function addRange(to, from) {
         if (to && from) {
-            for (var _i = 0; _i < from.length; _i++) {
-                var v = from[_i];
+            for (var _i = 0, from_1 = from; _i < from_1.length; _i++) {
+                var v = from_1[_i];
                 to.push(v);
             }
         }
@@ -512,8 +521,8 @@ var ts;
     function getNormalizedParts(normalizedSlashedPath, rootLength) {
         var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator);
         var normalized = [];
-        for (var _i = 0; _i < parts.length; _i++) {
-            var part = parts[_i];
+        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+            var part = parts_1[_i];
             if (part !== ".") {
                 if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
@@ -661,8 +670,8 @@ var ts;
         if (!fileName) {
             return false;
         }
-        for (var _i = 0; _i < ts.supportedExtensions.length; _i++) {
-            var extension = ts.supportedExtensions[_i];
+        for (var _i = 0, supportedExtensions_1 = ts.supportedExtensions; _i < supportedExtensions_1.length; _i++) {
+            var extension = supportedExtensions_1[_i];
             if (fileExtensionIs(fileName, extension)) {
                 return true;
             }
@@ -672,8 +681,8 @@ var ts;
     ts.isSupportedSourceFileName = isSupportedSourceFileName;
     var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     function removeFileExtension(path) {
-        for (var _i = 0; _i < extensionsToRemove.length; _i++) {
-            var ext = extensionsToRemove[_i];
+        for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
+            var ext = extensionsToRemove_1[_i];
             if (fileExtensionIs(path, ext)) {
                 return path.substr(0, path.length - ext.length);
             }
@@ -747,8 +756,8 @@ var ts;
     })(Debug = ts.Debug || (ts.Debug = {}));
     function copyListRemovingItem(item, list) {
         var copiedList = [];
-        for (var _i = 0; _i < list.length; _i++) {
-            var e = list[_i];
+        for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+            var e = list_1[_i];
             if (e !== item) {
                 copiedList.push(e);
             }
@@ -834,16 +843,16 @@ var ts;
                 function visitDirectory(path) {
                     var folder = fso.GetFolder(path || ".");
                     var files = getNames(folder.files);
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        var current = files_1[_i];
                         var name_1 = ts.combinePaths(path, current);
                         if ((!extension || ts.fileExtensionIs(name_1, extension)) && !ts.contains(exclude, getCanonicalPath(name_1))) {
                             result.push(name_1);
                         }
                     }
                     var subfolders = getNames(folder.subfolders);
-                    for (var _a = 0; _a < subfolders.length; _a++) {
-                        var current = subfolders[_a];
+                    for (var _a = 0, subfolders_1 = subfolders; _a < subfolders_1.length; _a++) {
+                        var current = subfolders_1[_a];
                         var name_2 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_2))) {
                             visitDirectory(name_2);
@@ -894,6 +903,7 @@ var ts;
             var _fs = require("fs");
             var _path = require("path");
             var _os = require("os");
+            var _tty = require("tty");
             function createWatchedFileSet(interval, chunkSize) {
                 if (interval === void 0) { interval = 2500; }
                 if (chunkSize === void 0) { chunkSize = 30; }
@@ -1006,8 +1016,8 @@ var ts;
                 function visitDirectory(path) {
                     var files = _fs.readdirSync(path || ".").sort();
                     var directories = [];
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_2 = files; _i < files_2.length; _i++) {
+                        var current = files_2[_i];
                         var name_3 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_3))) {
                             var stat = _fs.statSync(name_3);
@@ -1021,8 +1031,8 @@ var ts;
                             }
                         }
                     }
-                    for (var _a = 0; _a < directories.length; _a++) {
-                        var current = directories[_a];
+                    for (var _a = 0, directories_1 = directories; _a < directories_1.length; _a++) {
+                        var current = directories_1[_a];
                         visitDirectory(current);
                     }
                 }
@@ -1032,14 +1042,7 @@ var ts;
                 newLine: _os.EOL,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 write: function (s) {
-                    var buffer = new Buffer(s, "utf8");
-                    var offset = 0;
-                    var toWrite = buffer.length;
-                    var written = 0;
-                    while ((written = _fs.writeSync(1, buffer, offset, toWrite)) < toWrite) {
-                        offset += written;
-                        toWrite -= written;
-                    }
+                    process.stdout.write(s);
                 },
                 readFile: readFile,
                 writeFile: writeFile,
@@ -1306,6 +1309,7 @@ var ts;
         await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: ts.DiagnosticCategory.Error, key: "await_expression_is_only_allowed_within_an_async_function_1308", message: "'await' expression is only allowed within an async function." },
         Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: ts.DiagnosticCategory.Error, key: "Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher_1311", message: "Async functions are only available when targeting ECMAScript 6 and higher." },
         can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: { code: 1312, category: ts.DiagnosticCategory.Error, key: "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", message: "'=' can only be used in an object literal property inside a destructuring assignment." },
+        The_body_of_an_if_statement_cannot_be_the_empty_statement: { code: 1313, category: ts.DiagnosticCategory.Error, key: "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", message: "The body of an 'if' statement cannot be the empty statement." },
         Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_2300", message: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.DiagnosticCategory.Error, key: "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", message: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: ts.DiagnosticCategory.Error, key: "Static_members_cannot_reference_class_type_parameters_2302", message: "Static members cannot reference class type parameters." },
@@ -1358,7 +1362,7 @@ var ts;
         Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: ts.DiagnosticCategory.Error, key: "Neither_type_0_nor_type_1_is_assignable_to_the_other_2352", message: "Neither type '{0}' nor type '{1}' is assignable to the other." },
         Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: ts.DiagnosticCategory.Error, key: "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", message: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
         No_best_common_type_exists_among_return_expressions: { code: 2354, category: ts.DiagnosticCategory.Error, key: "No_best_common_type_exists_among_return_expressions_2354", message: "No best common type exists among return expressions." },
-        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_th_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." },
+        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value." },
         An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: ts.DiagnosticCategory.Error, key: "An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type_2356", message: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
         The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: ts.DiagnosticCategory.Error, key: "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer_2357", message: "The operand of an increment or decrement operator must be a variable, property or indexer." },
         The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", message: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." },
@@ -1379,7 +1383,7 @@ var ts;
         Duplicate_number_index_signature: { code: 2375, category: ts.DiagnosticCategory.Error, key: "Duplicate_number_index_signature_2375", message: "Duplicate number index signature." },
         A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: ts.DiagnosticCategory.Error, key: "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", message: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." },
         Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: ts.DiagnosticCategory.Error, key: "Constructors_for_derived_classes_must_contain_a_super_call_2377", message: "Constructors for derived classes must contain a 'super' call." },
-        A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement_2378", message: "A 'get' accessor must return a value or consist of a single 'throw' statement." },
+        A_get_accessor_must_return_a_value: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_2378", message: "A 'get' accessor must return a value." },
         Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: ts.DiagnosticCategory.Error, key: "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", message: "Getter and setter accessors do not agree in visibility." },
         get_and_set_accessor_must_have_the_same_type: { code: 2380, category: ts.DiagnosticCategory.Error, key: "get_and_set_accessor_must_have_the_same_type_2380", message: "'get' and 'set' accessor must have the same type." },
         A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: ts.DiagnosticCategory.Error, key: "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", message: "A signature with an implementation cannot use a string literal type." },
@@ -1669,8 +1673,6 @@ var ts;
         NEWLINE: { code: 6061, category: ts.DiagnosticCategory.Message, key: "NEWLINE_6061", message: "NEWLINE" },
         Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: ts.DiagnosticCategory.Error, key: "Argument_for_newLine_option_must_be_CRLF_or_LF_6062", message: "Argument for '--newLine' option must be 'CRLF' or 'LF'." },
         Argument_for_moduleResolution_option_must_be_node_or_classic: { code: 6063, category: ts.DiagnosticCategory.Error, key: "Argument_for_moduleResolution_option_must_be_node_or_classic_6063", message: "Argument for '--moduleResolution' option must be 'node' or 'classic'." },
-        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
-        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Enables_experimental_support_for_ES7_decorators: { code: 6065, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_decorators_6065", message: "Enables experimental support for ES7 decorators." },
         Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", message: "Enables experimental support for emitting type metadata for decorators." },
         Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_async_functions_6068", message: "Enables experimental support for ES7 async functions." },
@@ -1678,7 +1680,14 @@ var ts;
         Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: ts.DiagnosticCategory.Message, key: "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", message: "Initializes a TypeScript project and creates a tsconfig.json file." },
         Successfully_created_a_tsconfig_json_file: { code: 6071, category: ts.DiagnosticCategory.Message, key: "Successfully_created_a_tsconfig_json_file_6071", message: "Successfully created a tsconfig.json file." },
         Suppress_excess_property_checks_for_object_literals: { code: 6072, category: ts.DiagnosticCategory.Message, key: "Suppress_excess_property_checks_for_object_literals_6072", message: "Suppress excess property checks for object literals." },
-        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6073", message: "Disallow inconsistently-cased references to the same file." },
+        Stylize_errors_and_messages_using_color_and_context_experimental: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Stylize_errors_and_messages_using_color_and_context_experimental_6073", message: "Stylize errors and messages using color and context. (experimental)" },
+        Do_not_report_errors_on_unused_labels: { code: 6074, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unused_labels_6074", message: "Do not report errors on unused labels." },
+        Report_error_when_not_all_code_paths_in_function_return_a_value: { code: 6075, category: ts.DiagnosticCategory.Message, key: "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", message: "Report error when not all code paths in function return a value." },
+        Report_errors_for_fallthrough_cases_in_switch_statement: { code: 6076, category: ts.DiagnosticCategory.Message, key: "Report_errors_for_fallthrough_cases_in_switch_statement_6076", message: "Report errors for fallthrough cases in switch statement." },
+        Do_not_report_errors_on_unreachable_code: { code: 6077, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unreachable_code_6077", message: "Do not report errors on unreachable code." },
+        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6078, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6078", message: "Disallow inconsistently-cased references to the same file." },
+        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
+        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Variable_0_implicitly_has_an_1_type: { code: 7005, category: ts.DiagnosticCategory.Error, key: "Variable_0_implicitly_has_an_1_type_7005", message: "Variable '{0}' implicitly has an '{1}' type." },
         Parameter_0_implicitly_has_an_1_type: { code: 7006, category: ts.DiagnosticCategory.Error, key: "Parameter_0_implicitly_has_an_1_type_7006", message: "Parameter '{0}' implicitly has an '{1}' type." },
         Member_0_implicitly_has_an_1_type: { code: 7008, category: ts.DiagnosticCategory.Error, key: "Member_0_implicitly_has_an_1_type_7008", message: "Member '{0}' implicitly has an '{1}' type." },
@@ -1696,6 +1705,10 @@ var ts;
         Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: ts.DiagnosticCategory.Error, key: "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", message: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
         Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: ts.DiagnosticCategory.Error, key: "Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_typ_7025", message: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
         JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: ts.DiagnosticCategory.Error, key: "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", message: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
+        Unreachable_code_detected: { code: 7027, category: ts.DiagnosticCategory.Error, key: "Unreachable_code_detected_7027", message: "Unreachable code detected." },
+        Unused_label: { code: 7028, category: ts.DiagnosticCategory.Error, key: "Unused_label_7028", message: "Unused label." },
+        Fallthrough_case_in_switch: { code: 7029, category: ts.DiagnosticCategory.Error, key: "Fallthrough_case_in_switch_7029", message: "Fallthrough case in switch." },
+        Not_all_code_paths_return_a_value: { code: 7030, category: ts.DiagnosticCategory.Error, key: "Not_all_code_paths_return_a_value_7030", message: "Not all code paths return a value." },
         You_cannot_rename_this_element: { code: 8000, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_this_element_8000", message: "You cannot rename this element." },
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", message: "You cannot rename elements that are defined in the standard TypeScript library." },
         import_can_only_be_used_in_a_ts_file: { code: 8002, category: ts.DiagnosticCategory.Error, key: "import_can_only_be_used_in_a_ts_file_8002", message: "'import ... =' can only be used in a .ts file." },
@@ -3082,6 +3095,13 @@ var ts;
 var ts;
 (function (ts) {
     ts.bindTime = 0;
+    function or(state1, state2) {
+        return (state1 | state2) & 2
+            ? 2
+            : (state1 & state2) & 8
+                ? 8
+                : 4;
+    }
     function getModuleInstanceState(node) {
         if (node.kind === 215 || node.kind === 216) {
             return 0;
@@ -3089,7 +3109,7 @@ var ts;
         else if (ts.isConstEnumDeclaration(node)) {
             return 2;
         }
-        else if ((node.kind === 222 || node.kind === 221) && !(node.flags & 1)) {
+        else if ((node.kind === 222 || node.kind === 221) && !(node.flags & 2)) {
             return 0;
         }
         else if (node.kind === 219) {
@@ -3116,28 +3136,52 @@ var ts;
         }
     }
     ts.getModuleInstanceState = getModuleInstanceState;
-    function bindSourceFile(file) {
+    var binder = createBinder();
+    function bindSourceFile(file, options) {
         var start = new Date().getTime();
-        bindSourceFileWorker(file);
+        binder(file, options);
         ts.bindTime += new Date().getTime() - start;
     }
     ts.bindSourceFile = bindSourceFile;
-    function bindSourceFileWorker(file) {
+    function createBinder() {
+        var file;
+        var options;
         var parent;
         var container;
         var blockScopeContainer;
         var lastContainer;
         var seenThisKeyword;
-        var inStrictMode = !!file.externalModuleIndicator;
+        var hasExplicitReturn;
+        var currentReachabilityState;
+        var labelStack;
+        var labelIndexMap;
+        var implicitLabels;
+        var inStrictMode;
         var symbolCount = 0;
-        var Symbol = ts.objectAllocator.getSymbolConstructor();
-        var classifiableNames = {};
-        if (!file.locals) {
-            bind(file);
-            file.symbolCount = symbolCount;
-            file.classifiableNames = classifiableNames;
+        var Symbol;
+        var classifiableNames;
+        function bindSourceFile(f, opts) {
+            file = f;
+            options = opts;
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            Symbol = ts.objectAllocator.getSymbolConstructor();
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            hasExplicitReturn = false;
+            labelStack = undefined;
+            labelIndexMap = undefined;
+            implicitLabels = undefined;
         }
-        return;
+        return bindSourceFile;
         function createSymbol(flags, name) {
             symbolCount++;
             return new Symbol(flags, name);
@@ -3188,7 +3232,7 @@ var ts;
                     return node.isExportEquals ? "export=" : "default";
                 case 213:
                 case 214:
-                    return node.flags & 1024 ? "default" : undefined;
+                    return node.flags & 512 ? "default" : undefined;
             }
         }
         function getDisplayName(node) {
@@ -3196,7 +3240,7 @@ var ts;
         }
         function declareSymbol(symbolTable, parent, node, includes, excludes) {
             ts.Debug.assert(!ts.hasDynamicName(node));
-            var isDefaultExport = node.flags & 1024;
+            var isDefaultExport = node.flags & 512;
             var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
             var symbol;
             if (name !== undefined) {
@@ -3214,7 +3258,7 @@ var ts;
                         ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : ts.Diagnostics.Duplicate_identifier_0;
                     ts.forEach(symbol.declarations, function (declaration) {
-                        if (declaration.flags & 1024) {
+                        if (declaration.flags & 512) {
                             message = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
                         }
                     });
@@ -3233,7 +3277,7 @@ var ts;
             return symbol;
         }
         function declareModuleMember(node, symbolFlags, symbolExcludes) {
-            var hasExportModifier = ts.getCombinedNodeFlags(node) & 1;
+            var hasExportModifier = ts.getCombinedNodeFlags(node) & 2;
             if (symbolFlags & 8388608) {
                 if (node.kind === 230 || (node.kind === 221 && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -3243,7 +3287,7 @@ var ts;
                 }
             }
             else {
-                if (hasExportModifier || container.flags & 262144) {
+                if (hasExportModifier || container.flags & 131072) {
                     var exportKind = (symbolFlags & 107455 ? 1048576 : 0) |
                         (symbolFlags & 793056 ? 2097152 : 0) |
                         (symbolFlags & 1536 ? 4194304 : 0);
@@ -3274,18 +3318,202 @@ var ts;
                 blockScopeContainer = node;
                 blockScopeContainer.locals = undefined;
             }
-            if (node.kind === 215) {
+            var savedReachabilityState;
+            var savedLabelStack;
+            var savedLabels;
+            var savedImplicitLabels;
+            var savedHasExplicitReturn;
+            var kind = node.kind;
+            var flags = node.flags;
+            flags &= ~1572864;
+            if (kind === 215) {
                 seenThisKeyword = false;
-                ts.forEachChild(node, bind);
-                node.flags = seenThisKeyword ? node.flags | 524288 : node.flags & ~524288;
             }
-            else {
-                ts.forEachChild(node, bind);
+            var saveState = kind === 248 || kind === 219 || ts.isFunctionLikeKind(kind);
+            if (saveState) {
+                savedReachabilityState = currentReachabilityState;
+                savedLabelStack = labelStack;
+                savedLabels = labelIndexMap;
+                savedImplicitLabels = implicitLabels;
+                savedHasExplicitReturn = hasExplicitReturn;
+                currentReachabilityState = 2;
+                hasExplicitReturn = false;
+                labelStack = labelIndexMap = implicitLabels = undefined;
+            }
+            bindReachableStatement(node);
+            if (currentReachabilityState === 2 && ts.isFunctionLikeKind(kind) && ts.nodeIsPresent(node.body)) {
+                flags |= 524288;
+                if (hasExplicitReturn) {
+                    flags |= 1048576;
+                }
+            }
+            if (kind === 215) {
+                flags = seenThisKeyword ? flags | 262144 : flags & ~262144;
+            }
+            node.flags = flags;
+            if (saveState) {
+                hasExplicitReturn = savedHasExplicitReturn;
+                currentReachabilityState = savedReachabilityState;
+                labelStack = savedLabelStack;
+                labelIndexMap = savedLabels;
+                implicitLabels = savedImplicitLabels;
             }
             container = saveContainer;
             parent = saveParent;
             blockScopeContainer = savedBlockScopeContainer;
         }
+        function bindReachableStatement(node) {
+            if (checkUnreachable(node)) {
+                ts.forEachChild(node, bind);
+                return;
+            }
+            switch (node.kind) {
+                case 198:
+                    bindWhileStatement(node);
+                    break;
+                case 197:
+                    bindDoStatement(node);
+                    break;
+                case 199:
+                    bindForStatement(node);
+                    break;
+                case 200:
+                case 201:
+                    bindForInOrForOfStatement(node);
+                    break;
+                case 196:
+                    bindIfStatement(node);
+                    break;
+                case 204:
+                case 208:
+                    bindReturnOrThrow(node);
+                    break;
+                case 203:
+                case 202:
+                    bindBreakOrContinueStatement(node);
+                    break;
+                case 209:
+                    bindTryStatement(node);
+                    break;
+                case 206:
+                    bindSwitchStatement(node);
+                    break;
+                case 220:
+                    bindCaseBlock(node);
+                    break;
+                case 207:
+                    bindLabeledStatement(node);
+                    break;
+                default:
+                    ts.forEachChild(node, bind);
+                    break;
+            }
+        }
+        function bindWhileStatement(n) {
+            var preWhileState = n.expression.kind === 84 ? 4 : currentReachabilityState;
+            var postWhileState = n.expression.kind === 99 ? 4 : currentReachabilityState;
+            bind(n.expression);
+            currentReachabilityState = preWhileState;
+            var postWhileLabel = pushImplicitLabel();
+            bind(n.statement);
+            popImplicitLabel(postWhileLabel, postWhileState);
+        }
+        function bindDoStatement(n) {
+            var preDoState = currentReachabilityState;
+            var postDoLabel = pushImplicitLabel();
+            bind(n.statement);
+            var postDoState = n.expression.kind === 99 ? 4 : preDoState;
+            popImplicitLabel(postDoLabel, postDoState);
+            bind(n.expression);
+        }
+        function bindForStatement(n) {
+            var preForState = currentReachabilityState;
+            var postForLabel = pushImplicitLabel();
+            bind(n.initializer);
+            bind(n.condition);
+            bind(n.incrementor);
+            bind(n.statement);
+            var isInfiniteLoop = (!n.condition || n.condition.kind === 99);
+            var postForState = isInfiniteLoop ? 4 : preForState;
+            popImplicitLabel(postForLabel, postForState);
+        }
+        function bindForInOrForOfStatement(n) {
+            var preStatementState = currentReachabilityState;
+            var postStatementLabel = pushImplicitLabel();
+            bind(n.initializer);
+            bind(n.expression);
+            bind(n.statement);
+            popImplicitLabel(postStatementLabel, preStatementState);
+        }
+        function bindIfStatement(n) {
+            var ifTrueState = n.expression.kind === 84 ? 4 : currentReachabilityState;
+            var ifFalseState = n.expression.kind === 99 ? 4 : currentReachabilityState;
+            currentReachabilityState = ifTrueState;
+            bind(n.expression);
+            bind(n.thenStatement);
+            if (n.elseStatement) {
+                var preElseState = currentReachabilityState;
+                currentReachabilityState = ifFalseState;
+                bind(n.elseStatement);
+                currentReachabilityState = or(currentReachabilityState, preElseState);
+            }
+            else {
+                currentReachabilityState = or(currentReachabilityState, ifFalseState);
+            }
+        }
+        function bindReturnOrThrow(n) {
+            bind(n.expression);
+            if (n.kind === 204) {
+                hasExplicitReturn = true;
+            }
+            currentReachabilityState = 4;
+        }
+        function bindBreakOrContinueStatement(n) {
+            bind(n.label);
+            var isValidJump = jumpToLabel(n.label, n.kind === 203 ? currentReachabilityState : 4);
+            if (isValidJump) {
+                currentReachabilityState = 4;
+            }
+        }
+        function bindTryStatement(n) {
+            var preTryState = currentReachabilityState;
+            bind(n.tryBlock);
+            var postTryState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.catchClause);
+            var postCatchState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.finallyBlock);
+            currentReachabilityState = or(postTryState, postCatchState);
+        }
+        function bindSwitchStatement(n) {
+            var preSwitchState = currentReachabilityState;
+            var postSwitchLabel = pushImplicitLabel();
+            bind(n.expression);
+            bind(n.caseBlock);
+            var hasDefault = ts.forEach(n.caseBlock.clauses, function (c) { return c.kind === 242; });
+            var postSwitchState = hasDefault && currentReachabilityState !== 2 ? 4 : preSwitchState;
+            popImplicitLabel(postSwitchLabel, postSwitchState);
+        }
+        function bindCaseBlock(n) {
+            var startState = currentReachabilityState;
+            for (var _i = 0, _a = n.clauses; _i < _a.length; _i++) {
+                var clause = _a[_i];
+                currentReachabilityState = startState;
+                bind(clause);
+                if (clause.statements.length && currentReachabilityState === 2 && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, ts.Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+        function bindLabeledStatement(n) {
+            bind(n.label);
+            var ok = pushNamedLabel(n.label);
+            bind(n.statement);
+            if (ok) {
+                popNamedLabel(n.label, currentReachabilityState);
+            }
+        }
         function getContainerFlags(node) {
             switch (node.kind) {
                 case 186:
@@ -3365,7 +3593,7 @@ var ts;
             }
         }
         function declareClassMember(node, symbolFlags, symbolExcludes) {
-            return node.flags & 128
+            return node.flags & 64
                 ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
                 : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
         }
@@ -3374,15 +3602,6 @@ var ts;
                 ? declareModuleMember(node, symbolFlags, symbolExcludes)
                 : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
         }
-        function isAmbientContext(node) {
-            while (node) {
-                if (node.flags & 2) {
-                    return true;
-                }
-                node = node.parent;
-            }
-            return false;
-        }
         function hasExportDeclarations(node) {
             var body = node.kind === 248 ? node : node.body;
             if (body.kind === 248 || body.kind === 219) {
@@ -3396,11 +3615,11 @@ var ts;
             return false;
         }
         function setExportContextFlag(node) {
-            if (isAmbientContext(node) && !hasExportDeclarations(node)) {
-                node.flags |= 262144;
+            if (ts.isInAmbientContext(node) && !hasExportDeclarations(node)) {
+                node.flags |= 131072;
             }
             else {
-                node.flags &= ~262144;
+                node.flags &= ~131072;
             }
         }
         function bindModuleDeclaration(node) {
@@ -3551,7 +3770,7 @@ var ts;
             }
         }
         function checkStrictModeNumericLiteral(node) {
-            if (inStrictMode && node.flags & 65536) {
+            if (inStrictMode && node.flags & 32768) {
                 file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
         }
@@ -3569,10 +3788,10 @@ var ts;
         }
         function checkStrictModeWithStatement(node) {
             if (inStrictMode) {
-                grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
             }
         }
-        function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+        function errorOnFirstToken(node, message, arg0, arg1, arg2) {
             var span = ts.getSpanOfTokenAtPosition(file, node.pos);
             file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
         }
@@ -3580,6 +3799,9 @@ var ts;
             return "__" + ts.indexOf(node.parent.parameters, node);
         }
         function bind(node) {
+            if (!node) {
+                return;
+            }
             node.parent = parent;
             var savedInStrictMode = inStrictMode;
             if (!savedInStrictMode) {
@@ -3607,8 +3829,8 @@ var ts;
             }
         }
         function updateStrictModeStatementList(statements) {
-            for (var _i = 0; _i < statements.length; _i++) {
-                var statement = statements[_i];
+            for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+                var statement = statements_1[_i];
                 if (!ts.isPrologueDirective(statement)) {
                     return;
                 }
@@ -3795,7 +4017,7 @@ var ts;
             else {
                 declareSymbolAndAddToSymbolTable(node, 1, 107455);
             }
-            if (node.flags & 112 &&
+            if (node.flags & 56 &&
                 node.parent.kind === 144 &&
                 ts.isClassLike(node.parent.parent)) {
                 var classDeclaration = node.parent.parent;
@@ -3807,6 +4029,95 @@ var ts;
                 ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
+        function pushNamedLabel(name) {
+            initializeReachabilityStateIfNecessary();
+            if (ts.hasProperty(labelIndexMap, name.text)) {
+                return false;
+            }
+            labelIndexMap[name.text] = labelStack.push(1) - 1;
+            return true;
+        }
+        function pushImplicitLabel() {
+            initializeReachabilityStateIfNecessary();
+            var index = labelStack.push(1) - 1;
+            implicitLabels.push(index);
+            return index;
+        }
+        function popNamedLabel(label, outerState) {
+            var index = labelIndexMap[label.text];
+            ts.Debug.assert(index !== undefined);
+            ts.Debug.assert(labelStack.length == index + 1);
+            labelIndexMap[label.text] = undefined;
+            setCurrentStateAtLabel(labelStack.pop(), outerState, label);
+        }
+        function popImplicitLabel(implicitLabelIndex, outerState) {
+            if (labelStack.length !== implicitLabelIndex + 1) {
+                ts.Debug.assert(false, "Label stack: " + labelStack.length + ", index:" + implicitLabelIndex);
+            }
+            var i = implicitLabels.pop();
+            if (implicitLabelIndex !== i) {
+                ts.Debug.assert(false, "i: " + i + ", index: " + implicitLabelIndex);
+            }
+            setCurrentStateAtLabel(labelStack.pop(), outerState, undefined);
+        }
+        function setCurrentStateAtLabel(innerMergedState, outerState, label) {
+            if (innerMergedState === 1) {
+                if (label && !options.allowUnusedLabels) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(label, ts.Diagnostics.Unused_label));
+                }
+                currentReachabilityState = outerState;
+            }
+            else {
+                currentReachabilityState = or(innerMergedState, outerState);
+            }
+        }
+        function jumpToLabel(label, outerState) {
+            initializeReachabilityStateIfNecessary();
+            var index = label ? labelIndexMap[label.text] : ts.lastOrUndefined(implicitLabels);
+            if (index === undefined) {
+                return false;
+            }
+            var stateAtLabel = labelStack[index];
+            labelStack[index] = stateAtLabel === 1 ? outerState : or(stateAtLabel, outerState);
+            return true;
+        }
+        function checkUnreachable(node) {
+            switch (currentReachabilityState) {
+                case 4:
+                    var reportError = ts.isStatement(node) ||
+                        node.kind === 214 ||
+                        (node.kind === 218 && shouldReportErrorOnModuleDeclaration(node)) ||
+                        (node.kind === 217 && (!ts.isConstEnumDeclaration(node) || options.preserveConstEnums));
+                    if (reportError) {
+                        currentReachabilityState = 8;
+                        var reportUnreachableCode = !options.allowUnreachableCode &&
+                            !ts.isInAmbientContext(node) &&
+                            (node.kind !== 193 ||
+                                ts.getCombinedNodeFlags(node.declarationList) & 24576 ||
+                                ts.forEach(node.declarationList.declarations, function (d) { return d.initializer; }));
+                        if (reportUnreachableCode) {
+                            errorOnFirstToken(node, ts.Diagnostics.Unreachable_code_detected);
+                        }
+                    }
+                case 8:
+                    return true;
+                default:
+                    return false;
+            }
+            function shouldReportErrorOnModuleDeclaration(node) {
+                var instanceState = getModuleInstanceState(node);
+                return instanceState === 1 || (instanceState === 2 && options.preserveConstEnums);
+            }
+        }
+        function initializeReachabilityStateIfNecessary() {
+            if (labelIndexMap) {
+                return;
+            }
+            currentReachabilityState = 2;
+            labelIndexMap = {};
+            labelStack = [];
+            implicitLabels = [];
+        }
     }
 })(ts || (ts = {}));
 var ts;
@@ -3814,8 +4125,8 @@ var ts;
     function getDeclarationOfKind(symbol, kind) {
         var declarations = symbol.declarations;
         if (declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) {
+                var declaration = declarations_1[_i];
                 if (declaration.kind === kind) {
                     return declaration;
                 }
@@ -3985,7 +4296,7 @@ var ts;
     }
     ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName;
     function isBlockOrCatchScoped(declaration) {
-        return (getCombinedNodeFlags(declaration) & 49152) !== 0 ||
+        return (getCombinedNodeFlags(declaration) & 24576) !== 0 ||
             isCatchClauseVariableDeclaration(declaration);
     }
     ts.isBlockOrCatchScoped = isBlockOrCatchScoped;
@@ -4086,7 +4397,7 @@ var ts;
     }
     ts.isExternalModule = isExternalModule;
     function isDeclarationFile(file) {
-        return (file.flags & 8192) !== 0;
+        return (file.flags & 4096) !== 0;
     }
     ts.isDeclarationFile = isDeclarationFile;
     function isConstEnumDeclaration(node) {
@@ -4116,11 +4427,11 @@ var ts;
     }
     ts.getCombinedNodeFlags = getCombinedNodeFlags;
     function isConst(node) {
-        return !!(getCombinedNodeFlags(node) & 32768);
+        return !!(getCombinedNodeFlags(node) & 16384);
     }
     ts.isConst = isConst;
     function isLet(node) {
-        return !!(getCombinedNodeFlags(node) & 16384);
+        return !!(getCombinedNodeFlags(node) & 8192);
     }
     ts.isLet = isLet;
     function isPrologueDirective(node) {
@@ -4299,27 +4610,28 @@ var ts;
     }
     ts.isClassLike = isClassLike;
     function isFunctionLike(node) {
-        if (node) {
-            switch (node.kind) {
-                case 144:
-                case 173:
-                case 213:
-                case 174:
-                case 143:
-                case 142:
-                case 145:
-                case 146:
-                case 147:
-                case 148:
-                case 149:
-                case 152:
-                case 153:
-                    return true;
-            }
-        }
-        return false;
+        return node && isFunctionLikeKind(node.kind);
     }
     ts.isFunctionLike = isFunctionLike;
+    function isFunctionLikeKind(kind) {
+        switch (kind) {
+            case 144:
+            case 173:
+            case 213:
+            case 174:
+            case 143:
+            case 142:
+            case 145:
+            case 146:
+            case 147:
+            case 148:
+            case 149:
+            case 152:
+            case 153:
+                return true;
+        }
+    }
+    ts.isFunctionLikeKind = isFunctionLikeKind;
     function introducesArgumentsExoticObject(node) {
         switch (node.kind) {
             case 143:
@@ -4783,9 +5095,18 @@ var ts;
         return !!node && (node.kind === 162 || node.kind === 161);
     }
     ts.isBindingPattern = isBindingPattern;
+    function isNodeDescendentOf(node, ancestor) {
+        while (node) {
+            if (node === ancestor)
+                return true;
+            node = node.parent;
+        }
+        return false;
+    }
+    ts.isNodeDescendentOf = isNodeDescendentOf;
     function isInAmbientContext(node) {
         while (node) {
-            if (node.flags & (2 | 8192)) {
+            if (node.flags & (4 | 4096)) {
                 return true;
             }
             node = node.parent;
@@ -4843,7 +5164,7 @@ var ts;
             case 207:
             case 204:
             case 206:
-            case 98:
+            case 208:
             case 209:
             case 193:
             case 198:
@@ -4942,8 +5263,8 @@ var ts;
     ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes;
     function getHeritageClause(clauses, kind) {
         if (clauses) {
-            for (var _i = 0; _i < clauses.length; _i++) {
-                var clause = clauses[_i];
+            for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) {
+                var clause = clauses_1[_i];
                 if (clause.token === kind) {
                     return clause;
                 }
@@ -4955,7 +5276,6 @@ var ts;
     function tryResolveScriptReference(host, sourceFile, reference) {
         if (!host.getCompilerOptions().noResolve) {
             var referenceFileName = ts.isRootedDiskPath(reference.fileName) ? reference.fileName : ts.combinePaths(ts.getDirectoryPath(sourceFile.fileName), reference.fileName);
-            referenceFileName = ts.getNormalizedAbsolutePath(referenceFileName, host.getCurrentDirectory());
             return host.getSourceFile(referenceFileName);
         }
     }
@@ -5013,7 +5333,7 @@ var ts;
     }
     ts.isTrivia = isTrivia;
     function isAsyncFunctionLike(node) {
-        return isFunctionLike(node) && (node.flags & 512) !== 0 && !isAccessor(node);
+        return isFunctionLike(node) && (node.flags & 256) !== 0 && !isAccessor(node);
     }
     ts.isAsyncFunctionLike = isAsyncFunctionLike;
     function hasDynamicName(declaration) {
@@ -5371,7 +5691,7 @@ var ts;
         else {
             ts.forEach(declarations, function (member) {
                 if ((member.kind === 145 || member.kind === 146)
-                    && (member.flags & 128) === (accessor.flags & 128)) {
+                    && (member.flags & 64) === (accessor.flags & 64)) {
                     var memberName = getPropertyNameForPropertyNameNode(member.name);
                     var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
                     if (memberName === accessorName) {
@@ -5426,6 +5746,49 @@ var ts;
         });
     }
     ts.emitComments = emitComments;
+    function emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, removeComments) {
+        var leadingComments;
+        var currentDetachedCommentInfo;
+        if (removeComments) {
+            if (node.pos === 0) {
+                leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComment);
+            }
+        }
+        else {
+            leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
+        }
+        if (leadingComments) {
+            var detachedComments = [];
+            var lastComment;
+            for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) {
+                var comment = leadingComments_1[_i];
+                if (lastComment) {
+                    var lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end);
+                    var commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos);
+                    if (commentLine >= lastCommentLine + 2) {
+                        break;
+                    }
+                }
+                detachedComments.push(comment);
+                lastComment = comment;
+            }
+            if (detachedComments.length) {
+                var lastCommentLine = getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
+                var nodeLine = getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
+                if (nodeLine >= lastCommentLine + 2) {
+                    emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
+                    emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment);
+                    currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
+                }
+            }
+        }
+        return currentDetachedCommentInfo;
+        function isPinnedComment(comment) {
+            return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 &&
+                currentSourceFile.text.charCodeAt(comment.pos + 2) === 33;
+        }
+    }
+    ts.emitDetachedComments = emitDetachedComments;
     function writeCommentRange(currentSourceFile, writer, comment, newLine) {
         if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42) {
             var firstCommentLineAndCharacter = ts.getLineAndCharacterOfPosition(currentSourceFile, comment.pos);
@@ -5490,16 +5853,16 @@ var ts;
     ts.writeCommentRange = writeCommentRange;
     function modifierToFlag(token) {
         switch (token) {
-            case 113: return 128;
-            case 112: return 16;
-            case 111: return 64;
-            case 110: return 32;
-            case 115: return 256;
-            case 82: return 1;
-            case 122: return 2;
-            case 74: return 32768;
-            case 77: return 1024;
-            case 118: return 512;
+            case 113: return 64;
+            case 112: return 8;
+            case 111: return 32;
+            case 110: return 16;
+            case 115: return 128;
+            case 82: return 2;
+            case 122: return 4;
+            case 74: return 16384;
+            case 77: return 512;
+            case 118: return 256;
         }
         return 0;
     }
@@ -5578,7 +5941,7 @@ var ts;
     }
     ts.isEmptyObjectLiteralOrArrayLiteral = isEmptyObjectLiteralOrArrayLiteral;
     function getLocalSymbolForExportDefault(symbol) {
-        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 1024) ? symbol.valueDeclaration.localSymbol : undefined;
+        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 512) ? symbol.valueDeclaration.localSymbol : undefined;
     }
     ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault;
     function isJavaScript(fileName) {
@@ -5642,6 +6005,12 @@ var ts;
         return result;
     }
     ts.convertToBase64 = convertToBase64;
+    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+        return !ts.isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : ts.getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
+    }
+    ts.convertToRelativePath = convertToRelativePath;
     var carriageReturnLineFeed = "\r\n";
     var lineFeed = "\n";
     function getNewLineCharacter(options) {
@@ -5814,8 +6183,8 @@ var ts;
     }
     function visitEachNode(cbNode, nodes) {
         if (nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
                 var result = cbNode(node);
                 if (result) {
                     return result;
@@ -6276,8 +6645,8 @@ var ts;
         function addJSDocComment(node) {
             var comments = ts.getLeadingCommentRangesOfNode(node, sourceFile);
             if (comments) {
-                for (var _i = 0; _i < comments.length; _i++) {
-                    var comment = comments[_i];
+                for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+                    var comment = comments_1[_i];
                     var jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
                     if (jsDocComment) {
                         node.jsDocComment = jsDocComment;
@@ -6308,7 +6677,7 @@ var ts;
             sourceFile.bindDiagnostics = [];
             sourceFile.languageVersion = languageVersion;
             sourceFile.fileName = ts.normalizePath(fileName);
-            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 8192 : 0;
+            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 4096 : 0;
             sourceFile.languageVariant = ts.isTsx(sourceFile.fileName) ? 1 : 0;
             return sourceFile;
         }
@@ -7144,7 +7513,7 @@ var ts;
             if (node.kind === 8
                 && sourceText.charCodeAt(tokenPos) === 48
                 && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
-                node.flags |= 65536;
+                node.flags |= 32768;
             }
             return node;
         }
@@ -7713,7 +8082,7 @@ var ts;
             if (!arrowFunction) {
                 return undefined;
             }
-            var isAsync = !!(arrowFunction.flags & 512);
+            var isAsync = !!(arrowFunction.flags & 256);
             var lastToken = token;
             arrowFunction.equalsGreaterThanToken = parseExpectedToken(34, false, ts.Diagnostics._0_expected, "=>");
             arrowFunction.body = (lastToken === 34 || lastToken === 15)
@@ -7805,7 +8174,7 @@ var ts;
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) {
             var node = createNode(174);
             setModifiers(node, parseModifiersForArrowFunction());
-            var isAsync = !!(node.flags & 512);
+            var isAsync = !!(node.flags & 256);
             fillSignature(54, false, isAsync, !allowAmbiguity, node);
             if (!node.parameters) {
                 return undefined;
@@ -8419,7 +8788,7 @@ var ts;
             var node = createNode(164);
             parseExpected(19);
             if (scanner.hasPrecedingLineBreak())
-                node.flags |= 2048;
+                node.flags |= 1024;
             node.elements = parseDelimitedList(15, parseArgumentOrArrayLiteralElement);
             parseExpected(20);
             return finishNode(node);
@@ -8474,7 +8843,7 @@ var ts;
             var node = createNode(165);
             parseExpected(15);
             if (scanner.hasPrecedingLineBreak()) {
-                node.flags |= 2048;
+                node.flags |= 1024;
             }
             node.properties = parseDelimitedList(12, parseObjectLiteralElement, true);
             parseExpected(16);
@@ -8490,7 +8859,7 @@ var ts;
             parseExpected(87);
             node.asteriskToken = parseOptionalToken(37);
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512);
+            var isAsync = !!(node.flags & 256);
             node.name =
                 isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
                     isGenerator ? doInYieldContext(parseOptionalIdentifier) :
@@ -9028,10 +9397,10 @@ var ts;
                 case 102:
                     break;
                 case 108:
-                    node.flags |= 16384;
+                    node.flags |= 8192;
                     break;
                 case 74:
-                    node.flags |= 32768;
+                    node.flags |= 16384;
                     break;
                 default:
                     ts.Debug.fail();
@@ -9065,9 +9434,9 @@ var ts;
             setModifiers(node, modifiers);
             parseExpected(87);
             node.asteriskToken = parseOptionalToken(37);
-            node.name = node.flags & 1024 ? parseOptionalIdentifier() : parseIdentifier();
+            node.name = node.flags & 512 ? parseOptionalIdentifier() : parseIdentifier();
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512);
+            var isAsync = !!(node.flags & 256);
             fillSignature(54, isGenerator, isAsync, false, node);
             node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
             return finishNode(node);
@@ -9089,7 +9458,7 @@ var ts;
             method.name = name;
             method.questionToken = questionToken;
             var isGenerator = !!asteriskToken;
-            var isAsync = !!(method.flags & 512);
+            var isAsync = !!(method.flags & 256);
             fillSignature(54, isGenerator, isAsync, false, method);
             method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
             return finishNode(method);
@@ -9101,7 +9470,7 @@ var ts;
             property.name = name;
             property.questionToken = questionToken;
             property.type = parseTypeAnnotation();
-            property.initializer = modifiers && modifiers.flags & 128
+            property.initializer = modifiers && modifiers.flags & 64
                 ? allowInAnd(parseNonParameterInitializer)
                 : doOutsideOfContext(2 | 1, parseNonParameterInitializer);
             parseSemicolon();
@@ -9391,13 +9760,13 @@ var ts;
         }
         function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) {
             var node = createNode(218, fullStart);
-            var namespaceFlag = flags & 131072;
+            var namespaceFlag = flags & 65536;
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.flags |= flags;
             node.name = parseIdentifier();
             node.body = parseOptional(21)
-                ? parseModuleOrNamespaceDeclaration(getNodePos(), undefined, undefined, 1 | namespaceFlag)
+                ? parseModuleOrNamespaceDeclaration(getNodePos(), undefined, undefined, 2 | namespaceFlag)
                 : parseModuleBlock();
             return finishNode(node);
         }
@@ -9412,7 +9781,7 @@ var ts;
         function parseModuleDeclaration(fullStart, decorators, modifiers) {
             var flags = modifiers ? modifiers.flags : 0;
             if (parseOptional(126)) {
-                flags |= 131072;
+                flags |= 65536;
             }
             else {
                 parseExpected(125);
@@ -9626,7 +9995,7 @@ var ts;
         }
         function setExternalModuleIndicator(sourceFile) {
             sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) {
-                return node.flags & 1
+                return node.flags & 2
                     || node.kind === 221 && node.moduleReference.kind === 232
                     || node.kind === 222
                     || node.kind === 227
@@ -10200,8 +10569,8 @@ var ts;
                 array._children = undefined;
                 array.pos += delta;
                 array.end += delta;
-                for (var _i = 0; _i < array.length; _i++) {
-                    var node = array[_i];
+                for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
+                    var node = array_7[_i];
                     visitNode(node);
                 }
             }
@@ -10273,8 +10642,8 @@ var ts;
                     array.intersectsChange = true;
                     array._children = undefined;
                     adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
-                    for (var _i = 0; _i < array.length; _i++) {
-                        var node = array[_i];
+                    for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
+                        var node = array_8[_i];
                         visitNode(node);
                     }
                     return;
@@ -10547,6 +10916,7 @@ var ts;
         var getInstantiatedGlobalPromiseLikeType;
         var getGlobalPromiseConstructorLikeType;
         var getGlobalThenableType;
+        var jsxElementClassType;
         var tupleTypes = {};
         var unionTypes = {};
         var intersectionTypes = {};
@@ -10795,7 +11165,7 @@ var ts;
                     }
                     var initializerOfNonStaticProperty = current.parent &&
                         current.parent.kind === 141 &&
-                        (current.parent.flags & 128) === 0 &&
+                        (current.parent.flags & 64) === 0 &&
                         current.parent.initializer === current;
                     if (initializerOfNonStaticProperty) {
                         return true;
@@ -10854,7 +11224,7 @@ var ts;
                         break;
                     case 141:
                     case 140:
-                        if (ts.isClassLike(location.parent) && !(location.flags & 128)) {
+                        if (ts.isClassLike(location.parent) && !(location.flags & 64)) {
                             var ctor = findConstructorDeclaration(location.parent);
                             if (ctor && ctor.locals) {
                                 if (getSymbol(ctor.locals, name, meaning & 107455)) {
@@ -10867,7 +11237,7 @@ var ts;
                     case 186:
                     case 215:
                         if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) {
-                            if (lastLocation && lastLocation.flags & 128) {
+                            if (lastLocation && lastLocation.flags & 64) {
                                 error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
                                 return undefined;
                             }
@@ -11301,8 +11671,8 @@ var ts;
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
-            for (var _i = 0; _i < members.length; _i++) {
-                var member = members[_i];
+            for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+                var member = members_1[_i];
                 if (member.kind === 144 && ts.nodeIsPresent(member.body)) {
                     return member;
                 }
@@ -11508,7 +11878,7 @@ var ts;
                 if (!isDeclarationVisible(declaration)) {
                     var anyImportSyntax = getAnyImportSyntax(declaration);
                     if (anyImportSyntax &&
-                        !(anyImportSyntax.flags & 1) &&
+                        !(anyImportSyntax.flags & 2) &&
                         isDeclarationVisible(anyImportSyntax.parent)) {
                         getNodeLinks(declaration).isVisible = true;
                         if (aliasesToMakeVisible) {
@@ -11638,8 +12008,8 @@ var ts;
                             walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning));
                         }
                         if (accessibleSymbolChain) {
-                            for (var _i = 0; _i < accessibleSymbolChain.length; _i++) {
-                                var accessibleSymbol = accessibleSymbolChain[_i];
+                            for (var _i = 0, accessibleSymbolChain_1 = accessibleSymbolChain; _i < accessibleSymbolChain_1.length; _i++) {
+                                var accessibleSymbol = accessibleSymbolChain_1[_i];
                                 appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
                             }
                         }
@@ -11805,7 +12175,7 @@ var ts;
                     }
                     function shouldWriteTypeOfFunctionSymbol() {
                         var isStaticMethodSymbol = !!(symbol.flags & 8192 &&
-                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 128; }));
+                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 64; }));
                         var isNonLocalFunctionSymbol = !!(symbol.flags & 16) &&
                             (symbol.parent ||
                                 ts.forEach(symbol.declarations, function (declaration) {
@@ -11911,8 +12281,8 @@ var ts;
                         var t = getTypeOfSymbol(p);
                         if (p.flags & (16 | 8192) && !getPropertiesOfObjectType(t).length) {
                             var signatures = getSignaturesOfType(t, 0);
-                            for (var _f = 0; _f < signatures.length; _f++) {
-                                var signature = signatures[_f];
+                            for (var _f = 0, signatures_1 = signatures; _f < signatures_1.length; _f++) {
+                                var signature = signatures_1[_f];
                                 buildSymbolDisplay(p, writer);
                                 if (p.flags & 536870912) {
                                     writePunctuation(writer, 53);
@@ -12115,7 +12485,7 @@ var ts;
                     case 217:
                     case 221:
                         var parent_4 = getDeclarationContainer(node);
-                        if (!(ts.getCombinedNodeFlags(node) & 1) &&
+                        if (!(ts.getCombinedNodeFlags(node) & 2) &&
                             !(node.kind !== 221 && parent_4.kind !== 248 && ts.isInAmbientContext(parent_4))) {
                             return isGlobalSourceFile(parent_4);
                         }
@@ -12126,7 +12496,7 @@ var ts;
                     case 146:
                     case 143:
                     case 142:
-                        if (node.flags & (32 | 64)) {
+                        if (node.flags & (16 | 32)) {
                             return false;
                         }
                     case 144:
@@ -12555,8 +12925,8 @@ var ts;
             }
         }
         function appendTypeParameters(typeParameters, declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
+                var declaration = declarations_2[_i];
                 var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
                 if (!typeParameters) {
                     typeParameters = [tp];
@@ -12737,13 +13107,13 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var declaration = _a[_i];
                 if (declaration.kind === 215) {
-                    if (declaration.flags & 524288) {
+                    if (declaration.flags & 262144) {
                         return false;
                     }
                     var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
                     if (baseTypeNodes) {
-                        for (var _b = 0; _b < baseTypeNodes.length; _b++) {
-                            var node = baseTypeNodes[_b];
+                        for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
+                            var node = baseTypeNodes_1[_b];
                             if (ts.isSupportedExpressionWithTypeArguments(node)) {
                                 var baseSymbol = resolveEntityName(node.expression, 793056, true);
                                 if (!baseSymbol || !(baseSymbol.flags & 64) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
@@ -12911,23 +13281,23 @@ var ts;
         }
         function createSymbolTable(symbols) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                var symbol = symbols_1[_i];
                 result[symbol.name] = symbol;
             }
             return result;
         }
         function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+                var symbol = symbols_2[_i];
                 result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
             }
             return result;
         }
         function addInheritedMembers(symbols, baseSymbols) {
-            for (var _i = 0; _i < baseSymbols.length; _i++) {
-                var s = baseSymbols[_i];
+            for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
+                var s = baseSymbols_1[_i];
                 if (!ts.hasProperty(symbols, s.name)) {
                     symbols[s.name] = s;
                 }
@@ -12935,8 +13305,8 @@ var ts;
         }
         function addInheritedSignatures(signatures, baseSignatures) {
             if (baseSignatures) {
-                for (var _i = 0; _i < baseSignatures.length; _i++) {
-                    var signature = baseSignatures[_i];
+                for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
+                    var signature = baseSignatures_1[_i];
                     signatures.push(signature);
                 }
             }
@@ -12979,8 +13349,8 @@ var ts;
                     members = createSymbolTable(source.declaredProperties);
                 }
                 var thisArgument = ts.lastOrUndefined(typeArguments);
-                for (var _i = 0; _i < baseTypes.length; _i++) {
-                    var baseType = baseTypes[_i];
+                for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
+                    var baseType = baseTypes_1[_i];
                     var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
                     addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
                     callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0));
@@ -13026,8 +13396,8 @@ var ts;
             var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode);
             var typeArgCount = typeArguments ? typeArguments.length : 0;
             var result = [];
-            for (var _i = 0; _i < baseSignatures.length; _i++) {
-                var baseSig = baseSignatures[_i];
+            for (var _i = 0, baseSignatures_2 = baseSignatures; _i < baseSignatures_2.length; _i++) {
+                var baseSig = baseSignatures_2[_i];
                 var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
                 if (typeParamCount === typeArgCount) {
                     var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
@@ -13055,8 +13425,8 @@ var ts;
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
         }
         function findMatchingSignature(signatureList, signature, partialMatch, ignoreReturnTypes) {
-            for (var _i = 0; _i < signatureList.length; _i++) {
-                var s = signatureList[_i];
+            for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
+                var s = signatureList_1[_i];
                 if (compareSignatures(s, signature, partialMatch, ignoreReturnTypes, compareTypes)) {
                     return s;
                 }
@@ -13110,8 +13480,8 @@ var ts;
         }
         function getUnionIndexType(types, kind) {
             var indexTypes = [];
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+                var type = types_1[_i];
                 var indexType = getIndexTypeOfType(type, kind);
                 if (!indexType) {
                     return undefined;
@@ -13275,12 +13645,12 @@ var ts;
         function createUnionOrIntersectionProperty(containingType, name) {
             var types = containingType.types;
             var props;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
+                var current = types_2[_i];
                 var type = getApparentType(current);
                 if (type !== unknownType) {
                     var prop = getPropertyOfType(type, name);
-                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (32 | 64))) {
+                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (16 | 32))) {
                         if (!props) {
                             props = [prop];
                         }
@@ -13301,8 +13671,8 @@ var ts;
             }
             var propTypes = [];
             var declarations = [];
-            for (var _a = 0; _a < props.length; _a++) {
-                var prop = props[_a];
+            for (var _a = 0, props_1 = props; _a < props_1.length; _a++) {
+                var prop = props_1[_a];
                 if (prop.declarations) {
                     ts.addRange(declarations, prop.declarations);
                 }
@@ -13635,8 +14005,8 @@ var ts;
         }
         function getPropagatingFlagsOfTypes(types) {
             var result = 0;
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
+                var type = types_3[_i];
                 result |= type.flags;
             }
             return result & 14680064;
@@ -13757,8 +14127,8 @@ var ts;
         function getTypeOfGlobalSymbol(symbol, arity) {
             function getTypeDeclaration(symbol) {
                 var declarations = symbol.declarations;
-                for (var _i = 0; _i < declarations.length; _i++) {
-                    var declaration = declarations[_i];
+                for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
+                    var declaration = declarations_3[_i];
                     switch (declaration.kind) {
                         case 214:
                         case 215:
@@ -13856,8 +14226,8 @@ var ts;
             }
         }
         function addTypesToSet(typeSet, types, typeSetKind) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
+                var type = types_4[_i];
                 addTypeToSet(typeSet, type, typeSetKind);
             }
         }
@@ -13879,8 +14249,8 @@ var ts;
             }
         }
         function containsTypeAny(types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
+                var type = types_5[_i];
                 if (isTypeAny(type)) {
                     return true;
                 }
@@ -13983,7 +14353,8 @@ var ts;
             var container = ts.getThisContainer(node, false);
             var parent = container && container.parent;
             if (parent && (ts.isClassLike(parent) || parent.kind === 215)) {
-                if (!(container.flags & 128)) {
+                if (!(container.flags & 64) &&
+                    (container.kind !== 144 || ts.isNodeDescendentOf(node, container.body))) {
                     return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
                 }
             }
@@ -14048,8 +14419,8 @@ var ts;
         function instantiateList(items, mapper, instantiator) {
             if (items && items.length) {
                 var result = [];
-                for (var _i = 0; _i < items.length; _i++) {
-                    var v = items[_i];
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var v = items_1[_i];
                     result.push(instantiator(v, mapper));
                 }
                 return result;
@@ -14088,8 +14459,8 @@ var ts;
                 case 2: return createBinaryTypeEraser(sources[0], sources[1]);
             }
             return function (t) {
-                for (var _i = 0; _i < sources.length; _i++) {
-                    var source = sources[_i];
+                for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
+                    var source = sources_1[_i];
                     if (t === source) {
                         return anyType;
                     }
@@ -14454,8 +14825,8 @@ var ts;
             function eachTypeRelatedToSomeType(source, target) {
                 var result = -1;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
+                    var sourceType = sourceTypes_1[_i];
                     var related = typeRelatedToSomeType(sourceType, target, false);
                     if (!related) {
                         return 0;
@@ -14477,8 +14848,8 @@ var ts;
             function typeRelatedToEachType(source, target, reportErrors) {
                 var result = -1;
                 var targetTypes = target.types;
-                for (var _i = 0; _i < targetTypes.length; _i++) {
-                    var targetType = targetTypes[_i];
+                for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
+                    var targetType = targetTypes_1[_i];
                     var related = isRelatedTo(source, targetType, reportErrors);
                     if (!related) {
                         return 0;
@@ -14500,8 +14871,8 @@ var ts;
             function eachTypeRelatedToType(source, target, reportErrors) {
                 var result = -1;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_2 = sourceTypes; _i < sourceTypes_2.length; _i++) {
+                    var sourceType = sourceTypes_2[_i];
                     var related = isRelatedTo(sourceType, target, reportErrors);
                     if (!related) {
                         return 0;
@@ -14614,8 +14985,8 @@ var ts;
                 var result = -1;
                 var properties = getPropertiesOfObjectType(target);
                 var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 524288);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {
+                    var targetProp = properties_1[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
@@ -14629,20 +15000,20 @@ var ts;
                         else if (!(targetProp.flags & 134217728)) {
                             var sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
                             var targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
-                            if (sourcePropFlags & 32 || targetPropFlags & 32) {
+                            if (sourcePropFlags & 16 || targetPropFlags & 16) {
                                 if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
                                     if (reportErrors) {
-                                        if (sourcePropFlags & 32 && targetPropFlags & 32) {
+                                        if (sourcePropFlags & 16 && targetPropFlags & 16) {
                                             reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
                                         }
                                         else {
-                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 32 ? source : target), typeToString(sourcePropFlags & 32 ? target : source));
+                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 16 ? source : target), typeToString(sourcePropFlags & 16 ? target : source));
                                         }
                                     }
                                     return 0;
                                 }
                             }
-                            else if (targetPropFlags & 64) {
+                            else if (targetPropFlags & 32) {
                                 var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32;
                                 var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
                                 var targetClass = getDeclaredTypeOfSymbol(targetProp.parent);
@@ -14653,7 +15024,7 @@ var ts;
                                     return 0;
                                 }
                             }
-                            else if (sourcePropFlags & 64) {
+                            else if (sourcePropFlags & 32) {
                                 if (reportErrors) {
                                     reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
                                 }
@@ -14688,8 +15059,8 @@ var ts;
                     return 0;
                 }
                 var result = -1;
-                for (var _i = 0; _i < sourceProperties.length; _i++) {
-                    var sourceProp = sourceProperties[_i];
+                for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
+                    var sourceProp = sourceProperties_1[_i];
                     var targetProp = getPropertyOfObjectType(target, sourceProp.name);
                     if (!targetProp) {
                         return 0;
@@ -14721,13 +15092,13 @@ var ts;
                         return result;
                     }
                 }
-                outer: for (var _i = 0; _i < targetSignatures.length; _i++) {
-                    var t = targetSignatures[_i];
+                outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
+                    var t = targetSignatures_1[_i];
                     if (!t.hasStringLiterals || target.flags & 262144) {
                         var localErrors = reportErrors;
                         var checkedAbstractAssignability = false;
-                        for (var _a = 0; _a < sourceSignatures.length; _a++) {
-                            var s = sourceSignatures[_a];
+                        for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) {
+                            var s = sourceSignatures_1[_a];
                             if (!s.hasStringLiterals || source.flags & 262144) {
                                 var related = signatureRelatedTo(s, t, localErrors);
                                 if (related) {
@@ -14755,8 +15126,8 @@ var ts;
                         var targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
                         var sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
                         var targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
-                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 256;
-                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 256;
+                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 128;
+                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 128;
                         if (sourceIsAbstract && !(targetIsAbstract && targetDecl)) {
                             if (reportErrors) {
                                 reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
@@ -14957,8 +15328,8 @@ var ts;
             if (sourceProp === targetProp) {
                 return -1;
             }
-            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 | 64);
-            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 | 64);
+            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (16 | 32);
+            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (16 | 32);
             if (sourcePropAccessibility !== targetPropAccessibility) {
                 return 0;
             }
@@ -15024,8 +15395,8 @@ var ts;
             return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1;
         }
         function isSupertypeOfEach(candidate, types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_6 = types; _i < types_6.length; _i++) {
+                var type = types_6[_i];
                 if (candidate !== type && !isTypeSubtypeOf(type, candidate))
                     return false;
             }
@@ -15238,8 +15609,8 @@ var ts;
         }
         function createInferenceContext(typeParameters, inferUnionTypes) {
             var inferences = [];
-            for (var _i = 0; _i < typeParameters.length; _i++) {
-                var unused = typeParameters[_i];
+            for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
+                var unused = typeParameters_1[_i];
                 inferences.push({
                     primary: undefined, secondary: undefined, isFixed: false
                 });
@@ -15305,8 +15676,8 @@ var ts;
                     var targetTypes = target.types;
                     var typeParameterCount = 0;
                     var typeParameter;
-                    for (var _i = 0; _i < targetTypes.length; _i++) {
-                        var t = targetTypes[_i];
+                    for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
+                        var t = targetTypes_2[_i];
                         if (t.flags & 512 && ts.contains(context.typeParameters, t)) {
                             typeParameter = t;
                             typeParameterCount++;
@@ -15323,8 +15694,8 @@ var ts;
                 }
                 else if (source.flags & 49152) {
                     var sourceTypes = source.types;
-                    for (var _a = 0; _a < sourceTypes.length; _a++) {
-                        var sourceType = sourceTypes[_a];
+                    for (var _a = 0, sourceTypes_3 = sourceTypes; _a < sourceTypes_3.length; _a++) {
+                        var sourceType = sourceTypes_3[_a];
                         inferFromTypes(sourceType, target);
                     }
                 }
@@ -15357,8 +15728,8 @@ var ts;
             }
             function inferFromProperties(source, target) {
                 var properties = getPropertiesOfObjectType(target);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_2 = properties; _i < properties_2.length; _i++) {
+                    var targetProp = properties_2[_i];
                     var sourceProp = getPropertyOfObjectType(source, targetProp.name);
                     if (sourceProp) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
@@ -15849,7 +16220,7 @@ var ts;
                     break;
                 case 141:
                 case 140:
-                    if (container.flags & 128) {
+                    if (container.flags & 64) {
                         error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
                     }
                     break;
@@ -15862,7 +16233,7 @@ var ts;
             }
             if (ts.isClassLike(container.parent)) {
                 var symbol = getSymbolOfNode(container.parent);
-                return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
+                return container.flags & 64 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
             }
             return anyType;
         }
@@ -15890,7 +16261,7 @@ var ts;
             var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             var nodeCheckFlag = 0;
             if (canUseSuperExpression) {
-                if ((container.flags & 128) || isCallExpression) {
+                if ((container.flags & 64) || isCallExpression) {
                     nodeCheckFlag = 512;
                 }
                 else {
@@ -15935,7 +16306,7 @@ var ts;
                 }
                 else {
                     if (container && ts.isClassLike(container.parent)) {
-                        if (container.flags & 128) {
+                        if (container.flags & 64) {
                             return container.kind === 143 ||
                                 container.kind === 142 ||
                                 container.kind === 145 ||
@@ -16074,8 +16445,8 @@ var ts;
             var types = type.types;
             var mappedType;
             var mappedTypes;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
+                var current = types_7[_i];
                 var t = mapper(current);
                 if (t) {
                     if (!mappedType) {
@@ -16239,8 +16610,8 @@ var ts;
             }
             var signatureList;
             var types = type.types;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
+                var current = types_8[_i];
                 var signature = getNonGenericSignature(current);
                 if (signature) {
                     if (!signatureList) {
@@ -16291,8 +16662,8 @@ var ts;
             var hasSpreadElement = false;
             var elementTypes = [];
             var inDestructuringPattern = isAssignmentTarget(node);
-            for (var _i = 0; _i < elements.length; _i++) {
-                var e = elements[_i];
+            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+                var e = elements_1[_i];
                 if (inDestructuringPattern && e.kind === 185) {
                     var restArrayType = checkExpression(e.expression, contextualMapper);
                     var restElementType = getIndexTypeOfType(restArrayType, 1) ||
@@ -16551,8 +16922,8 @@ var ts;
         function checkJsxSpreadAttribute(node, elementAttributesType, nameTable) {
             var type = checkExpression(node.expression);
             var props = getPropertiesOfType(type);
-            for (var _i = 0; _i < props.length; _i++) {
-                var prop = props[_i];
+            for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+                var prop = props_2[_i];
                 if (!nameTable[prop.name]) {
                     var targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
                     if (targetPropSym) {
@@ -16721,7 +17092,6 @@ var ts;
             var prop = getPropertyOfType(attributesType, attrib.name.text);
             return prop || unknownSymbol;
         }
-        var jsxElementClassType = undefined;
         function getJsxGlobalElementClassType() {
             if (!jsxElementClassType) {
                 jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
@@ -16788,7 +17158,7 @@ var ts;
             return s.valueDeclaration ? s.valueDeclaration.kind : 141;
         }
         function getDeclarationFlagsFromSymbol(s) {
-            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0;
+            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 8 | 64 : 0;
         }
         function checkClassPropertyAccess(node, left, type, prop) {
             var flags = getDeclarationFlagsFromSymbol(prop);
@@ -16801,17 +17171,17 @@ var ts;
                     error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
                     return false;
                 }
-                if (flags & 256) {
+                if (flags & 128) {
                     error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(declaringClass));
                     return false;
                 }
             }
-            if (!(flags & (32 | 64))) {
+            if (!(flags & (16 | 32))) {
                 return true;
             }
             var enclosingClassDeclaration = ts.getContainingClass(node);
             var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
-            if (flags & 32) {
+            if (flags & 16) {
                 if (declaringClass !== enclosingClass) {
                     error(node, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass));
                     return false;
@@ -16825,7 +17195,7 @@ var ts;
                 error(node, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(declaringClass));
                 return false;
             }
-            if (flags & 128) {
+            if (flags & 64) {
                 return true;
             }
             if (type.flags & 33554432) {
@@ -17005,8 +17375,8 @@ var ts;
             var specializedIndex = -1;
             var spliceIndex;
             ts.Debug.assert(!result.length);
-            for (var _i = 0; _i < signatures.length; _i++) {
-                var signature = signatures[_i];
+            for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
+                var signature = signatures_2[_i];
                 var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
                 var parent_5 = signature.declaration && signature.declaration.parent;
                 if (!lastSymbol || symbol === lastSymbol) {
@@ -17417,8 +17787,8 @@ var ts;
                 reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
             }
             if (!produceDiagnostics) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var candidate = candidates[_i];
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
                     if (hasCorrectArity(node, args, candidate)) {
                         if (candidate.typeParameters && typeArguments) {
                             candidate = getSignatureInstantiation(candidate, ts.map(typeArguments, getTypeFromTypeNode));
@@ -17437,8 +17807,8 @@ var ts;
                 diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo));
             }
             function chooseOverload(candidates, relation) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var originalCandidate = candidates[_i];
+                for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+                    var originalCandidate = candidates_2[_i];
                     if (!hasCorrectArity(node, args, originalCandidate)) {
                         continue;
                     }
@@ -17541,7 +17911,7 @@ var ts;
                 return resolveErrorCall(node);
             }
             var valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-            if (valueDecl && valueDecl.flags & 256) {
+            if (valueDecl && valueDecl.flags & 128) {
                 error(node, ts.Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, ts.declarationNameToString(valueDecl.name));
                 return resolveErrorCall(node);
             }
@@ -17827,32 +18197,24 @@ var ts;
             });
             return aggregatedTypes;
         }
-        function bodyContainsAReturnStatement(funcBody) {
-            return ts.forEachReturnStatement(funcBody, function (returnStatement) {
-                return true;
-            });
-        }
-        function bodyContainsSingleThrowStatement(body) {
-            return (body.statements.length === 1) && (body.statements[0].kind === 208);
-        }
-        function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) {
+        function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
             if (!produceDiagnostics) {
                 return;
             }
             if (returnType === voidType || isTypeAny(returnType)) {
                 return;
             }
-            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192) {
+            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192 || !(func.flags & 524288)) {
                 return;
             }
-            var bodyBlock = func.body;
-            if (bodyContainsAReturnStatement(bodyBlock)) {
-                return;
+            if (func.flags & 1048576) {
+                if (compilerOptions.noImplicitReturns) {
+                    error(func.type, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                }
             }
-            if (bodyContainsSingleThrowStatement(bodyBlock)) {
-                return;
+            else {
+                error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
             }
-            error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement);
         }
         function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) {
             ts.Debug.assert(node.kind !== 143 || ts.isObjectLiteralMethod(node));
@@ -17911,7 +18273,7 @@ var ts;
                 promisedType = checkAsyncFunctionReturnType(node);
             }
             if (returnType && !node.asteriskToken) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (node.body) {
                 if (!node.type) {
@@ -17970,7 +18332,7 @@ var ts;
                     case 69:
                     case 166: {
                         var symbol = findSymbol(n);
-                        return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 32768) !== 0;
+                        return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 16384) !== 0;
                     }
                     case 167: {
                         var index = n.argumentExpression;
@@ -17978,7 +18340,7 @@ var ts;
                         if (symbol && index && index.kind === 9) {
                             var name_12 = index.text;
                             var prop = getPropertyOfType(getTypeOfSymbol(symbol), name_12);
-                            return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 32768) !== 0;
+                            return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 16384) !== 0;
                         }
                         return false;
                     }
@@ -18058,8 +18420,8 @@ var ts;
             }
             if (type.flags & 49152) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
+                    var current = types_9[_i];
                     if (current.flags & kind) {
                         return true;
                     }
@@ -18074,8 +18436,8 @@ var ts;
             }
             if (type.flags & 49152) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
+                    var current = types_10[_i];
                     if (!(current.flags & kind)) {
                         return false;
                     }
@@ -18110,8 +18472,8 @@ var ts;
         }
         function checkObjectLiteralAssignment(node, sourceType, contextualMapper) {
             var properties = node.properties;
-            for (var _i = 0; _i < properties.length; _i++) {
-                var p = properties[_i];
+            for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
+                var p = properties_3[_i];
                 if (p.kind === 245 || p.kind === 246) {
                     var name_13 = p.name;
                     var type = isTypeAny(sourceType)
@@ -18573,7 +18935,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             checkVariableLikeDeclaration(node);
             var func = ts.getContainingFunction(node);
-            if (node.flags & 112) {
+            if (node.flags & 56) {
                 func = ts.getContainingFunction(node);
                 if (!(func.kind === 144 && ts.nodeIsPresent(func.body))) {
                     error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
@@ -18754,7 +19116,7 @@ var ts;
         function checkMethodDeclaration(node) {
             checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name);
             checkFunctionLikeDeclaration(node);
-            if (node.flags & 256 && node.body) {
+            if (node.flags & 128 && node.body) {
                 error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
             }
         }
@@ -18801,7 +19163,7 @@ var ts;
             }
             function isInstancePropertyWithInitializer(n) {
                 return n.kind === 141 &&
-                    !(n.flags & 128) &&
+                    !(n.flags & 64) &&
                     !!n.initializer;
             }
             var containingClassDecl = node.parent;
@@ -18814,12 +19176,12 @@ var ts;
                         error(node, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
                     }
                     var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) ||
-                        ts.forEach(node.parameters, function (p) { return p.flags & (16 | 32 | 64); });
+                        ts.forEach(node.parameters, function (p) { return p.flags & (8 | 16 | 32); });
                     if (superCallShouldBeFirst) {
                         var statements = node.body.statements;
                         var superCallStatement;
-                        for (var _i = 0; _i < statements.length; _i++) {
-                            var statement = statements[_i];
+                        for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
+                            var statement = statements_2[_i];
                             if (statement.kind === 195 && isSuperCallExpression(statement.expression)) {
                                 superCallStatement = statement;
                                 break;
@@ -18845,15 +19207,22 @@ var ts;
             if (produceDiagnostics) {
                 checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
                 if (node.kind === 145) {
-                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) {
-                        error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);
+                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && (node.flags & 524288)) {
+                        if (node.flags & 1048576) {
+                            if (compilerOptions.noImplicitReturns) {
+                                error(node.name, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                            }
+                        }
+                        else {
+                            error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
+                        }
                     }
                 }
                 if (!ts.hasDynamicName(node)) {
                     var otherKind = node.kind === 145 ? 146 : 145;
                     var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind);
                     if (otherAccessor) {
-                        if (((node.flags & 112) !== (otherAccessor.flags & 112))) {
+                        if (((node.flags & 56) !== (otherAccessor.flags & 56))) {
                             error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
                         }
                         var currentAccessorType = getAnnotatedAccessorType(node);
@@ -18920,7 +19289,7 @@ var ts;
             ts.forEach(node.types, checkSourceElement);
         }
         function isPrivateWithinAmbient(node) {
-            return (node.flags & 32) && ts.isInAmbientContext(node);
+            return (node.flags & 16) && ts.isInAmbientContext(node);
         }
         function checkSpecializedSignatureDeclaration(signatureDeclarationNode) {
             if (!produceDiagnostics) {
@@ -18945,8 +19314,8 @@ var ts;
             else {
                 signaturesToCheck = getSignaturesOfSymbol(getSymbolOfNode(signatureDeclarationNode));
             }
-            for (var _i = 0; _i < signaturesToCheck.length; _i++) {
-                var otherSignature = signaturesToCheck[_i];
+            for (var _i = 0, signaturesToCheck_1 = signaturesToCheck; _i < signaturesToCheck_1.length; _i++) {
+                var otherSignature = signaturesToCheck_1[_i];
                 if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) {
                     return;
                 }
@@ -18959,10 +19328,10 @@ var ts;
                 n.parent.kind !== 214 &&
                 n.parent.kind !== 186 &&
                 ts.isInAmbientContext(n)) {
-                if (!(flags & 2)) {
-                    flags |= 1;
+                if (!(flags & 4)) {
+                    flags |= 2;
                 }
-                flags |= 2;
+                flags |= 4;
             }
             return flags & flagsToCheck;
         }
@@ -18980,16 +19349,16 @@ var ts;
                     var canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
                     ts.forEach(overloads, function (o) {
                         var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags;
-                        if (deviation & 1) {
+                        if (deviation & 2) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported);
                         }
-                        else if (deviation & 2) {
+                        else if (deviation & 4) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
                         }
-                        else if (deviation & (32 | 64)) {
+                        else if (deviation & (16 | 32)) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
                         }
-                        else if (deviation & 256) {
+                        else if (deviation & 128) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract);
                         }
                     });
@@ -19006,7 +19375,7 @@ var ts;
                     });
                 }
             }
-            var flagsToCheck = 1 | 2 | 32 | 64 | 256;
+            var flagsToCheck = 2 | 4 | 16 | 32 | 128;
             var someNodeFlags = 0;
             var allNodeFlags = flagsToCheck;
             var someHaveQuestionToken = false;
@@ -19035,8 +19404,8 @@ var ts;
                         var errorNode_1 = subsequentNode.name || subsequentNode;
                         if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) {
                             ts.Debug.assert(node.kind === 143 || node.kind === 142);
-                            ts.Debug.assert((node.flags & 128) !== (subsequentNode.flags & 128));
-                            var diagnostic = node.flags & 128 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
+                            ts.Debug.assert((node.flags & 64) !== (subsequentNode.flags & 64));
+                            var diagnostic = node.flags & 64 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
                             error(errorNode_1, diagnostic);
                             return;
                         }
@@ -19051,7 +19420,7 @@ var ts;
                     error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing);
                 }
                 else {
-                    if (node.flags & 256) {
+                    if (node.flags & 128) {
                         error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
                     }
                     else {
@@ -19062,8 +19431,8 @@ var ts;
             var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536;
             var duplicateFunctionDeclaration = false;
             var multipleConstructorImplementation = false;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var current = declarations[_i];
+            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                var current = declarations_4[_i];
                 var node = current;
                 var inAmbientContext = ts.isInAmbientContext(node);
                 var inAmbientContextOrInterface = node.parent.kind === 215 || node.parent.kind === 155 || inAmbientContext;
@@ -19112,7 +19481,7 @@ var ts;
                 });
             }
             if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
-                !(lastSeenNonAmbientDeclaration.flags & 256)) {
+                !(lastSeenNonAmbientDeclaration.flags & 128)) {
                 reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
             }
             if (hasOverloads) {
@@ -19122,8 +19491,8 @@ var ts;
                     var signatures = getSignaturesOfSymbol(symbol);
                     var bodySignature = getSignatureFromDeclaration(bodyDeclaration);
                     if (!bodySignature.hasStringLiterals) {
-                        for (var _a = 0; _a < signatures.length; _a++) {
-                            var signature = signatures[_a];
+                        for (var _a = 0, signatures_3 = signatures; _a < signatures_3.length; _a++) {
+                            var signature = signatures_3[_a];
                             if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) {
                                 error(signature.declaration, ts.Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
                                 break;
@@ -19153,9 +19522,9 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var d = _a[_i];
                 var declarationSpaces = getDeclarationSpaces(d);
-                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 | 1024);
-                if (effectiveDeclarationFlags & 1) {
-                    if (effectiveDeclarationFlags & 1024) {
+                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 2 | 512);
+                if (effectiveDeclarationFlags & 2) {
+                    if (effectiveDeclarationFlags & 512) {
                         defaultExportedDeclarationSpaces |= declarationSpaces;
                     }
                     else {
@@ -19291,9 +19660,12 @@ var ts;
             if (promiseType === unknownType && compilerOptions.isolatedModules) {
                 return unknownType;
             }
-            var promiseConstructor = getMergedSymbol(promiseType.symbol);
+            var promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
             if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
-                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType));
+                var typeName = promiseConstructor
+                    ? symbolToString(promiseConstructor)
+                    : typeToString(promiseType);
+                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeName);
                 return unknownType;
             }
             var promiseConstructorType = getTypeOfSymbol(promiseConstructor);
@@ -19452,7 +19824,7 @@ var ts;
                 if (isAsync) {
                     promisedType = checkAsyncFunctionReturnType(node);
                 }
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (produceDiagnostics && !node.type) {
                 if (compilerOptions.noImplicitAny && ts.nodeIsMissing(node.body) && !isPrivateWithinAmbient(node)) {
@@ -19555,7 +19927,7 @@ var ts;
             }
         }
         function checkVarDeclaredNamesNotShadowed(node) {
-            if ((ts.getCombinedNodeFlags(node) & 49152) !== 0 || ts.isParameterDeclaration(node)) {
+            if ((ts.getCombinedNodeFlags(node) & 24576) !== 0 || ts.isParameterDeclaration(node)) {
                 return;
             }
             if (node.kind === 211 && !node.initializer) {
@@ -19567,7 +19939,7 @@ var ts;
                 if (localDeclarationSymbol &&
                     localDeclarationSymbol !== symbol &&
                     localDeclarationSymbol.flags & 2) {
-                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 49152) {
+                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 24576) {
                         var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 212);
                         var container = varDeclList.parent.kind === 193 && varDeclList.parent.parent
                             ? varDeclList.parent.parent
@@ -19694,6 +20066,9 @@ var ts;
             checkGrammarStatementInAmbientContext(node);
             checkExpression(node.expression);
             checkSourceElement(node.thenStatement);
+            if (node.thenStatement.kind === 194) {
+                error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
+            }
             checkSourceElement(node.elseStatement);
         }
         function checkDoStatement(node) {
@@ -19943,7 +20318,7 @@ var ts;
                         error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value);
                     }
                     else if (func.kind === 144) {
-                        if (!isTypeAssignableTo(exprType, returnType)) {
+                        if (!checkTypeAssignableTo(exprType, returnType, node.expression)) {
                             error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
                         }
                     }
@@ -20073,7 +20448,7 @@ var ts;
                     var classDeclaration = type.symbol.valueDeclaration;
                     for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) {
                         var member = _a[_i];
-                        if (!(member.flags & 128) && ts.hasDynamicName(member)) {
+                        if (!(member.flags & 64) && ts.hasDynamicName(member)) {
                             var propType = getTypeOfSymbol(member.symbol);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1);
@@ -20149,7 +20524,7 @@ var ts;
             return getTypeOfSymbol(getSymbolOfNode(node));
         }
         function checkClassDeclaration(node) {
-            if (!node.name && !(node.flags & 1024)) {
+            if (!node.name && !(node.flags & 512)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
             }
             checkClassLikeDeclaration(node);
@@ -20199,8 +20574,8 @@ var ts;
             }
             var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
-                for (var _b = 0; _b < implementedTypeNodes.length; _b++) {
-                    var typeRefNode = implementedTypeNodes[_b];
+                for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
+                    var typeRefNode = implementedTypeNodes_1[_b];
                     if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) {
                         error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
@@ -20232,8 +20607,8 @@ var ts;
         }
         function checkKindsOfPropertyMemberOverrides(type, baseType) {
             var baseProperties = getPropertiesOfObjectType(baseType);
-            for (var _i = 0; _i < baseProperties.length; _i++) {
-                var baseProperty = baseProperties[_i];
+            for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 134217728) {
                     continue;
@@ -20244,7 +20619,7 @@ var ts;
                 if (derived) {
                     if (derived === base) {
                         var derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
-                        if (baseDeclarationFlags & 256 && (!derivedClassDecl || !(derivedClassDecl.flags & 256))) {
+                        if (baseDeclarationFlags & 128 && (!derivedClassDecl || !(derivedClassDecl.flags & 128))) {
                             if (derivedClassDecl.kind === 186) {
                                 error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
                             }
@@ -20255,10 +20630,10 @@ var ts;
                     }
                     else {
                         var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
-                        if ((baseDeclarationFlags & 32) || (derivedDeclarationFlags & 32)) {
+                        if ((baseDeclarationFlags & 16) || (derivedDeclarationFlags & 16)) {
                             continue;
                         }
-                        if ((baseDeclarationFlags & 128) !== (derivedDeclarationFlags & 128)) {
+                        if ((baseDeclarationFlags & 64) !== (derivedDeclarationFlags & 64)) {
                             continue;
                         }
                         if ((base.flags & derived.flags & 8192) || ((base.flags & 98308) && (derived.flags & 98308))) {
@@ -20324,11 +20699,11 @@ var ts;
             var seen = {};
             ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen[p.name] = { prop: p, containingType: type }; });
             var ok = true;
-            for (var _i = 0; _i < baseTypes.length; _i++) {
-                var base = baseTypes[_i];
+            for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
+                var base = baseTypes_2[_i];
                 var properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var prop = properties[_a];
+                for (var _a = 0, properties_4 = properties; _a < properties_4.length; _a++) {
+                    var prop = properties_4[_a];
                     if (!ts.hasProperty(seen, prop.name)) {
                         seen[prop.name] = { prop: prop, containingType: base };
                     }
@@ -20597,8 +20972,8 @@ var ts;
         }
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
             var declarations = symbol.declarations;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+                var declaration = declarations_5[_i];
                 if ((declaration.kind === 214 ||
                     (declaration.kind === 213 && ts.nodeIsPresent(declaration.body))) &&
                     !ts.isInAmbientContext(declaration)) {
@@ -20726,7 +21101,7 @@ var ts;
             if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
             }
             if (checkExternalImportOrExportDeclaration(node)) {
@@ -20753,7 +21128,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
                 checkImportBinding(node);
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     markExportAsReferenced(node);
                 }
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
@@ -20781,7 +21156,7 @@ var ts;
             if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
             }
             if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
@@ -20820,7 +21195,7 @@ var ts;
                 error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
             }
             if (node.expression.kind === 69) {
@@ -21205,7 +21580,7 @@ var ts;
                             }
                         case 214:
                         case 215:
-                            if (!(memberFlags & 128)) {
+                            if (!(memberFlags & 64)) {
                                 copySymbols(getSymbolOfNode(location).members, meaning & 793056);
                             }
                             break;
@@ -21467,7 +21842,7 @@ var ts;
         }
         function getParentTypeOfClassElement(node) {
             var classSymbol = getSymbolOfNode(node.parent);
-            return node.flags & 128
+            return node.flags & 64
                 ? getTypeOfSymbol(classSymbol)
                 : getDeclaredTypeOfSymbol(classSymbol);
         }
@@ -21753,7 +22128,7 @@ var ts;
         }
         function initializeTypeChecker() {
             ts.forEach(host.getSourceFiles(), function (file) {
-                ts.bindSourceFile(file);
+                ts.bindSourceFile(file, compilerOptions);
             });
             ts.forEach(host.getSourceFiles(), function (file) {
                 if (!ts.isExternalModule(file)) {
@@ -21897,19 +22272,19 @@ var ts;
                             text = "private";
                             lastPrivate = modifier;
                         }
-                        if (flags & 112) {
+                        if (flags & 56) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
                         }
-                        else if (flags & 128) {
+                        else if (flags & 64) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
                         }
                         else if (node.parent.kind === 219 || node.parent.kind === 248) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text);
                         }
-                        else if (flags & 256) {
+                        else if (flags & 128) {
                             if (modifier.kind === 110) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
                             }
@@ -21920,10 +22295,10 @@ var ts;
                         flags |= ts.modifierToFlag(modifier.kind);
                         break;
                     case 113:
-                        if (flags & 128) {
+                        if (flags & 64) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
                         }
                         else if (node.parent.kind === 219 || node.parent.kind === 248) {
@@ -21932,23 +22307,23 @@ var ts;
                         else if (node.kind === 138) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
                         }
-                        else if (flags & 256) {
+                        else if (flags & 128) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                         }
-                        flags |= 128;
+                        flags |= 64;
                         lastStatic = modifier;
                         break;
                     case 82:
-                        if (flags & 1) {
+                        if (flags & 2) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
                         }
-                        else if (flags & 2) {
+                        else if (flags & 4) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
                         }
-                        else if (flags & 256) {
+                        else if (flags & 128) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
                         }
                         else if (node.parent.kind === 214) {
@@ -21957,13 +22332,13 @@ var ts;
                         else if (node.kind === 138) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
                         }
-                        flags |= 1;
+                        flags |= 2;
                         break;
                     case 122:
-                        if (flags & 2) {
+                        if (flags & 4) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.parent.kind === 214) {
@@ -21975,69 +22350,69 @@ var ts;
                         else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 219) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
                         }
-                        flags |= 2;
+                        flags |= 4;
                         lastDeclare = modifier;
                         break;
                     case 115:
-                        if (flags & 256) {
+                        if (flags & 128) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
                         }
                         if (node.kind !== 214) {
                             if (node.kind !== 143) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_or_method_declaration);
                             }
-                            if (!(node.parent.kind === 214 && node.parent.flags & 256)) {
+                            if (!(node.parent.kind === 214 && node.parent.flags & 128)) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
                             }
-                            if (flags & 128) {
+                            if (flags & 64) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                             }
-                            if (flags & 32) {
+                            if (flags & 16) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
                             }
                         }
-                        flags |= 256;
+                        flags |= 128;
                         break;
                     case 118:
-                        if (flags & 512) {
+                        if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
                         }
-                        else if (flags & 2 || ts.isInAmbientContext(node.parent)) {
+                        else if (flags & 4 || ts.isInAmbientContext(node.parent)) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.kind === 138) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
                         }
-                        flags |= 512;
+                        flags |= 256;
                         lastAsync = modifier;
                         break;
                 }
             }
             if (node.kind === 144) {
-                if (flags & 128) {
+                if (flags & 64) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
                 }
-                if (flags & 256) {
+                if (flags & 128) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
                 }
-                else if (flags & 64) {
+                else if (flags & 32) {
                     return grammarErrorOnNode(lastProtected, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected");
                 }
-                else if (flags & 32) {
+                else if (flags & 16) {
                     return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private");
                 }
-                else if (flags & 512) {
+                else if (flags & 256) {
                     return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
                 }
                 return;
             }
-            else if ((node.kind === 222 || node.kind === 221) && flags & 2) {
+            else if ((node.kind === 222 || node.kind === 221) && flags & 4) {
                 return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
             }
-            else if (node.kind === 138 && (flags & 112) && ts.isBindingPattern(node.name)) {
+            else if (node.kind === 138 && (flags & 56) && ts.isBindingPattern(node.name)) {
                 return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern);
             }
-            if (flags & 512) {
+            if (flags & 256) {
                 return checkGrammarAsyncModifier(node, lastAsync);
             }
         }
@@ -22137,7 +22512,7 @@ var ts;
             if (parameter.dotDotDotToken) {
                 return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
             }
-            if (parameter.flags & 2035) {
+            if (parameter.flags & 1022) {
                 return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
             }
             if (parameter.questionToken) {
@@ -22157,7 +22532,7 @@ var ts;
             }
         }
         function checkGrammarForIndexSignatureModifier(node) {
-            if (node.flags & 2035) {
+            if (node.flags & 1022) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_not_permitted_on_index_signature_members);
             }
         }
@@ -22179,8 +22554,8 @@ var ts;
         function checkGrammarForOmittedArgument(node, args) {
             if (args) {
                 var sourceFile = ts.getSourceFileOfNode(node);
-                for (var _i = 0; _i < args.length; _i++) {
-                    var arg = args[_i];
+                for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+                    var arg = args_1[_i];
                     if (arg.kind === 187) {
                         return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
                     }
@@ -22420,7 +22795,7 @@ var ts;
                     if (parameter.dotDotDotToken) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
                     }
-                    else if (parameter.flags & 2035) {
+                    else if (parameter.flags & 1022) {
                         return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
                     }
                     else if (parameter.questionToken) {
@@ -22554,8 +22929,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0; _i < elements.length; _i++) {
-                    var element = elements[_i];
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
                     if (element.kind !== 187) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -22674,8 +23049,8 @@ var ts;
                 node.kind === 221 ||
                 node.kind === 228 ||
                 node.kind === 227 ||
-                (node.flags & 2) ||
-                (node.flags & (1 | 1024))) {
+                (node.flags & 4) ||
+                (node.flags & (2 | 512))) {
                 return false;
             }
             return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
@@ -22713,7 +23088,7 @@ var ts;
             }
         }
         function checkGrammarNumericLiteral(node) {
-            if (node.flags & 65536 && languageVersion >= 1) {
+            if (node.flags & 32768 && languageVersion >= 1) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
             }
         }
@@ -22760,7 +23135,7 @@ var ts;
                 var addedGlobalFileReference = false;
                 ts.forEach(root.referencedFiles, function (fileReference) {
                     var referencedFile = ts.tryResolveScriptReference(host, root, fileReference);
-                    if (referencedFile && ((referencedFile.flags & 8192) ||
+                    if (referencedFile && ((referencedFile.flags & 4096) ||
                         ts.shouldEmitToOwnFile(referencedFile, compilerOptions) ||
                         !addedGlobalFileReference)) {
                         writeReferencePath(referencedFile);
@@ -22938,15 +23313,15 @@ var ts;
             }
         }
         function emitLines(nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                var node = nodes_2[_i];
                 emit(node);
             }
         }
         function emitSeparatedList(nodes, separator, eachNodeEmitFn, canEmitFn) {
             var currentWriterPos = writer.getTextPos();
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+                var node = nodes_3[_i];
                 if (!canEmitFn || canEmitFn(node)) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         write(separator);
@@ -23088,6 +23463,7 @@ var ts;
         function emitSourceFile(node) {
             currentSourceFile = node;
             enclosingDeclaration = node;
+            ts.emitDetachedComments(currentSourceFile, writer, ts.writeCommentRange, node, newLine, true);
             emitLines(node.statements);
         }
         function getExportDefaultTempVariableName() {
@@ -23194,10 +23570,10 @@ var ts;
         }
         function emitModuleElementDeclarationFlags(node) {
             if (node.parent === currentSourceFile) {
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     write("export ");
                 }
-                if (node.flags & 1024) {
+                if (node.flags & 512) {
                     write("default ");
                 }
                 else if (node.kind !== 215) {
@@ -23206,22 +23582,22 @@ var ts;
             }
         }
         function emitClassMemberDeclarationFlags(node) {
-            if (node.flags & 32) {
+            if (node.flags & 16) {
                 write("private ");
             }
-            else if (node.flags & 64) {
+            else if (node.flags & 32) {
                 write("protected ");
             }
-            if (node.flags & 128) {
+            if (node.flags & 64) {
                 write("static ");
             }
-            if (node.flags & 256) {
+            if (node.flags & 128) {
                 write("abstract ");
             }
         }
         function writeImportEqualsDeclaration(node) {
             emitJsDocComments(node);
-            if (node.flags & 1) {
+            if (node.flags & 2) {
                 write("export ");
             }
             write("import ");
@@ -23256,11 +23632,11 @@ var ts;
             }
         }
         function writeImportDeclaration(node) {
-            if (!node.importClause && !(node.flags & 1)) {
+            if (!node.importClause && !(node.flags & 2)) {
                 return;
             }
             emitJsDocComments(node);
-            if (node.flags & 1) {
+            if (node.flags & 2) {
                 write("export ");
             }
             write("import ");
@@ -23322,7 +23698,7 @@ var ts;
         function writeModuleDeclaration(node) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 131072) {
+            if (node.flags & 65536) {
                 write("namespace ");
             }
             else {
@@ -23394,7 +23770,7 @@ var ts;
             writeLine();
         }
         function isPrivateMethodTypeParameter(node) {
-            return node.parent.kind === 143 && (node.parent.flags & 32);
+            return node.parent.kind === 143 && (node.parent.flags & 16);
         }
         function emitTypeParameters(typeParameters) {
             function emitTypeParameter(node) {
@@ -23436,7 +23812,7 @@ var ts;
                             break;
                         case 143:
                         case 142:
-                            if (node.parent.flags & 128) {
+                            if (node.parent.flags & 64) {
                                 diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                             }
                             else if (node.parent.parent.kind === 214) {
@@ -23499,7 +23875,7 @@ var ts;
             function emitParameterProperties(constructorDeclaration) {
                 if (constructorDeclaration) {
                     ts.forEach(constructorDeclaration.parameters, function (param) {
-                        if (param.flags & 112) {
+                        if (param.flags & 56) {
                             emitPropertyDeclaration(param);
                         }
                     });
@@ -23507,7 +23883,7 @@ var ts;
             }
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 256) {
+            if (node.flags & 128) {
                 write("abstract ");
             }
             write("class ");
@@ -23571,7 +23947,7 @@ var ts;
                     if ((node.kind === 141 || node.kind === 140) && node.parent.kind === 155) {
                         emitTypeOfVariableDeclarationFromTypeLiteral(node);
                     }
-                    else if (!(node.flags & 32)) {
+                    else if (!(node.flags & 16)) {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
@@ -23585,7 +23961,7 @@ var ts;
                         ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
                 }
                 else if (node.kind === 141 || node.kind === 140) {
-                    if (node.flags & 128) {
+                    if (node.flags & 64) {
                         return symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 ?
                                 ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -23680,7 +24056,7 @@ var ts;
                 emitJsDocComments(accessors.setAccessor);
                 emitClassMemberDeclarationFlags(node);
                 writeTextOfNode(currentSourceFile, node.name);
-                if (!(node.flags & 32)) {
+                if (!(node.flags & 16)) {
                     accessorWithTypeAnnotation = node;
                     var type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
@@ -23707,7 +24083,7 @@ var ts;
             function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) {
                 var diagnosticMessage;
                 if (accessorWithTypeAnnotation.kind === 146) {
-                    if (accessorWithTypeAnnotation.parent.flags & 128) {
+                    if (accessorWithTypeAnnotation.parent.flags & 64) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
@@ -23724,7 +24100,7 @@ var ts;
                     };
                 }
                 else {
-                    if (accessorWithTypeAnnotation.flags & 128) {
+                    if (accessorWithTypeAnnotation.flags & 64) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 ?
                                 ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -23805,7 +24181,7 @@ var ts;
                     emitType(node.type);
                 }
             }
-            else if (node.kind !== 144 && !(node.flags & 32)) {
+            else if (node.kind !== 144 && !(node.flags & 16)) {
                 writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
             }
             enclosingDeclaration = prevEnclosingDeclaration;
@@ -23833,7 +24209,7 @@ var ts;
                         break;
                     case 143:
                     case 142:
-                        if (node.flags & 128) {
+                        if (node.flags & 64) {
                             diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 ?
                                     ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -23890,7 +24266,7 @@ var ts;
                 node.parent.parent.kind === 155) {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
-            else if (!(node.parent.flags & 32)) {
+            else if (!(node.parent.flags & 16)) {
                 writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
             }
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) {
@@ -23919,7 +24295,7 @@ var ts;
                             ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
                     case 143:
                     case 142:
-                        if (node.parent.flags & 128) {
+                        if (node.parent.flags & 64) {
                             return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 ?
                                     ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -24035,7 +24411,7 @@ var ts;
             }
         }
         function writeReferencePath(referencedFile) {
-            var declFileName = referencedFile.flags & 8192
+            var declFileName = referencedFile.flags & 4096
                 ? referencedFile.fileName
                 : ts.shouldEmitToOwnFile(referencedFile, compilerOptions)
                     ? ts.getOwnEmitOutputFilePath(referencedFile, host, ".d.ts")
@@ -24368,16 +24744,8 @@ var ts;
             diagnostics: diagnostics,
             sourceMaps: sourceMapDataList
         };
-        function isNodeDescendentOf(node, ancestor) {
-            while (node) {
-                if (node === ancestor)
-                    return true;
-                node = node.parent;
-            }
-            return false;
-        }
         function isUniqueLocalName(name, container) {
-            for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {
+            for (var node = container; ts.isNodeDescendentOf(node, container); node = node.nextContainer) {
                 if (node.locals && ts.hasProperty(node.locals, name)) {
                     if (node.locals[name].flags & (107455 | 1048576 | 8388608)) {
                         return false;
@@ -25670,7 +26038,7 @@ var ts;
                     write("]");
                 }
                 else {
-                    emitListWithSpread(elements, true, (node.flags & 2048) !== 0, elements.hasTrailingComma, true);
+                    emitListWithSpread(elements, true, (node.flags & 1024) !== 0, elements.hasTrailingComma, true);
                 }
             }
             function emitObjectLiteralBody(node, numElements) {
@@ -25685,7 +26053,7 @@ var ts;
                         emitLinePreservingList(node, properties, languageVersion >= 1, true);
                     }
                     else {
-                        var multiLine = (node.flags & 2048) !== 0;
+                        var multiLine = (node.flags & 1024) !== 0;
                         if (!multiLine) {
                             write(" ");
                         }
@@ -25704,7 +26072,7 @@ var ts;
                 write("}");
             }
             function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) {
-                var multiLine = (node.flags & 2048) !== 0;
+                var multiLine = (node.flags & 1024) !== 0;
                 var properties = node.properties;
                 write("(");
                 if (multiLine) {
@@ -26222,7 +26590,7 @@ var ts;
                 var current = node;
                 while (current) {
                     if (current.kind === 248) {
-                        return !isExported || ((ts.getCombinedNodeFlags(node) & 1) !== 0);
+                        return !isExported || ((ts.getCombinedNodeFlags(node) & 2) !== 0);
                     }
                     else if (ts.isFunctionLike(current) || current.kind === 219) {
                         return false;
@@ -26440,7 +26808,7 @@ var ts;
                 if (shouldHoistVariable(decl, true)) {
                     return false;
                 }
-                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 49152) === 0) {
+                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 24576) === 0) {
                     for (var _a = 0, _b = decl.declarations; _a < _b.length; _a++) {
                         var varDecl = _b[_a];
                         hoistVariableDeclarationFromLoop(convertedLoopState, varDecl);
@@ -26522,7 +26890,7 @@ var ts;
                         break;
                 }
                 var loopParameters;
-                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 49152)) {
+                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 24576)) {
                     loopParameters = [];
                     for (var _a = 0, _b = loopInitializer.declarations; _a < _b.length; _a++) {
                         var varDeclaration = _b[_a];
@@ -26779,22 +27147,22 @@ var ts;
                 var endPos = emitToken(86, node.pos);
                 write(" ");
                 endPos = emitToken(17, endPos);
-                var rhsIsIdentifier = node.expression.kind === 69;
                 var counter = createTempVariable(268435456);
-                var rhsReference = rhsIsIdentifier ? node.expression : createTempVariable(0);
+                var rhsReference = ts.createSynthesizedNode(69);
+                rhsReference.text = node.expression.kind === 69 ?
+                    makeUniqueName(node.expression.text) :
+                    makeTempVariableName(0);
                 emitStart(node.expression);
                 write("var ");
                 emitNodeWithoutSourceMap(counter);
                 write(" = 0");
                 emitEnd(node.expression);
-                if (!rhsIsIdentifier) {
-                    write(", ");
-                    emitStart(node.expression);
-                    emitNodeWithoutSourceMap(rhsReference);
-                    write(" = ");
-                    emitNodeWithoutSourceMap(node.expression);
-                    emitEnd(node.expression);
-                }
+                write(", ");
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(rhsReference);
+                write(" = ");
+                emitNodeWithoutSourceMap(node.expression);
+                emitEnd(node.expression);
                 write("; ");
                 emitStart(node.initializer);
                 emitNodeWithoutSourceMap(counter);
@@ -27029,7 +27397,7 @@ var ts;
             }
             function emitModuleMemberName(node) {
                 emitStart(node.name);
-                if (ts.getCombinedNodeFlags(node) & 1) {
+                if (ts.getCombinedNodeFlags(node) & 2) {
                     var container = getContainingModule(node);
                     if (container) {
                         write(getGeneratedNameForNode(container));
@@ -27051,7 +27419,7 @@ var ts;
             }
             function emitEs6ExportDefaultCompat(node) {
                 if (node.parent.kind === 248) {
-                    ts.Debug.assert(!!(node.flags & 1024) || node.kind === 227);
+                    ts.Debug.assert(!!(node.flags & 512) || node.kind === 227);
                     if (modulekind === 1 || modulekind === 2 || modulekind === 3) {
                         if (!currentSourceFile.symbol.exports["___esModule"]) {
                             if (languageVersion === 1) {
@@ -27067,12 +27435,12 @@ var ts;
                 }
             }
             function emitExportMemberAssignment(node) {
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     writeLine();
                     emitStart(node);
                     if (modulekind === 4 && node.parent === currentSourceFile) {
                         write(exportFunctionForFile + "(\"");
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             write("default");
                         }
                         else {
@@ -27083,7 +27451,7 @@ var ts;
                         write(")");
                     }
                     else {
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             emitEs6ExportDefaultCompat(node);
                             if (languageVersion === 0) {
                                 write("exports[\"default\"]");
@@ -27171,7 +27539,7 @@ var ts;
                 var emitCount = 0;
                 var canDefineTempVariablesInPlace = false;
                 if (root.kind === 211) {
-                    var isExported = ts.getCombinedNodeFlags(root) & 1;
+                    var isExported = ts.getCombinedNodeFlags(root) & 2;
                     var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
                     canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind;
                 }
@@ -27237,8 +27605,8 @@ var ts;
                     if (properties.length !== 1) {
                         value = ensureIdentifier(value, true);
                     }
-                    for (var _a = 0; _a < properties.length; _a++) {
-                        var p = properties[_a];
+                    for (var _a = 0, properties_5 = properties; _a < properties_5.length; _a++) {
+                        var p = properties_5[_a];
                         if (p.kind === 245 || p.kind === 246) {
                             var propName = p.name;
                             var target_1 = p.kind === 246 ? p : p.initializer || propName;
@@ -27357,7 +27725,7 @@ var ts;
                     var initializer = node.initializer;
                     if (!initializer && languageVersion < 2) {
                         var isLetDefinedInLoop = (resolver.getNodeCheckFlags(node) & 16384) &&
-                            (getCombinedFlagsForIdentifier(node.name) & 16384);
+                            (getCombinedFlagsForIdentifier(node.name) & 8192);
                         if (isLetDefinedInLoop &&
                             node.parent.parent.kind !== 200 &&
                             node.parent.parent.kind !== 201) {
@@ -27396,13 +27764,13 @@ var ts;
                 return ts.getCombinedNodeFlags(node.parent);
             }
             function isES6ExportedDeclaration(node) {
-                return !!(node.flags & 1) &&
+                return !!(node.flags & 2) &&
                     modulekind === 5 &&
                     node.parent.kind === 248;
             }
             function emitVariableStatement(node) {
                 var startIsEmitted = false;
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     if (isES6ExportedDeclaration(node)) {
                         write("export ");
                         startIsEmitted = tryEmitStartOfVariableDeclarationList(node.declarationList);
@@ -27426,7 +27794,7 @@ var ts;
                 }
             }
             function shouldEmitLeadingAndTrailingCommentsForVariableStatement(node) {
-                if (!(node.flags & 1)) {
+                if (!(node.flags & 2)) {
                     return true;
                 }
                 if (isES6ExportedDeclaration(node)) {
@@ -27583,7 +27951,7 @@ var ts;
                 if (!shouldEmitAsArrowFunction(node)) {
                     if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             write("default ");
                         }
                     }
@@ -27722,7 +28090,7 @@ var ts;
                 emitRestParameter(node);
             }
             function emitExpressionFunctionBody(node, body) {
-                if (languageVersion < 2 || node.flags & 512) {
+                if (languageVersion < 2 || node.flags & 256) {
                     emitDownLevelExpressionFunctionBody(node, body);
                     return;
                 }
@@ -27738,7 +28106,7 @@ var ts;
                 scopeEmitStart(node);
                 increaseIndent();
                 var outPos = writer.getTextPos();
-                emitDetachedComments(node.body);
+                emitDetachedCommentsAndUpdateCommentsInfo(node.body);
                 emitFunctionBodyPreamble(node);
                 var preambleEmitted = writer.getTextPos() !== outPos;
                 decreaseIndent();
@@ -27774,7 +28142,7 @@ var ts;
                 scopeEmitStart(node);
                 var initialTextPos = writer.getTextPos();
                 increaseIndent();
-                emitDetachedComments(body.statements);
+                emitDetachedCommentsAndUpdateCommentsInfo(body.statements);
                 var startIndex = emitDirectivePrologues(body.statements, true);
                 emitFunctionBodyPreamble(node);
                 decreaseIndent();
@@ -27816,7 +28184,7 @@ var ts;
             }
             function emitParameterPropertyAssignments(node) {
                 ts.forEach(node.parameters, function (param) {
-                    if (param.flags & 112) {
+                    if (param.flags & 56) {
                         writeLine();
                         emitStart(param);
                         emitStart(param.name);
@@ -27848,15 +28216,15 @@ var ts;
                 var properties = [];
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
-                    if (member.kind === 141 && isStatic === ((member.flags & 128) !== 0) && member.initializer) {
+                    if (member.kind === 141 && isStatic === ((member.flags & 64) !== 0) && member.initializer) {
                         properties.push(member);
                     }
                 }
                 return properties;
             }
             function emitPropertyDeclarations(node, properties) {
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var property = properties[_a];
+                for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
+                    var property = properties_6[_a];
                     emitPropertyDeclaration(node, property);
                 }
             }
@@ -27869,7 +28237,7 @@ var ts;
                     emit(receiver);
                 }
                 else {
-                    if (property.flags & 128) {
+                    if (property.flags & 64) {
                         emitDeclarationName(node);
                     }
                     else {
@@ -27968,7 +28336,7 @@ var ts;
                         writeLine();
                         emitLeadingComments(member);
                         emitStart(member);
-                        if (member.flags & 128) {
+                        if (member.flags & 64) {
                             write("static ");
                         }
                         if (member.kind === 145) {
@@ -28013,7 +28381,7 @@ var ts;
                     if (member.kind === 144 && !member.body) {
                         emitCommentsOnNotEmittedNode(member);
                     }
-                    if (member.kind === 141 && member.initializer && (member.flags & 128) === 0) {
+                    if (member.kind === 141 && member.initializer && (member.flags & 64) === 0) {
                         hasInstancePropertyWithInitializer = true;
                     }
                 });
@@ -28050,7 +28418,7 @@ var ts;
                 increaseIndent();
                 if (ctor) {
                     startIndex = emitDirectivePrologues(ctor.body.statements, true);
-                    emitDetachedComments(ctor.body.statements);
+                    emitDetachedCommentsAndUpdateCommentsInfo(ctor.body.statements);
                 }
                 emitCaptureThisForNodeIfNecessary(node);
                 var superCall;
@@ -28121,7 +28489,7 @@ var ts;
                 var thisNodeIsDecorated = ts.nodeIsDecorated(node);
                 if (node.kind === 214) {
                     if (thisNodeIsDecorated) {
-                        if (isES6ExportedDeclaration(node) && !(node.flags & 1024)) {
+                        if (isES6ExportedDeclaration(node) && !(node.flags & 512)) {
                             write("export ");
                         }
                         write("let ");
@@ -28130,7 +28498,7 @@ var ts;
                     }
                     else if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             write("default ");
                         }
                     }
@@ -28146,7 +28514,7 @@ var ts;
                     write(" = ");
                 }
                 write("class");
-                if ((node.name || (node.flags & 1024 && staticProperties.length > 0)) && !thisNodeIsDecorated) {
+                if ((node.name || (node.flags & 512 && staticProperties.length > 0)) && !thisNodeIsDecorated) {
                     write(" ");
                     emitDeclarationName(node);
                 }
@@ -28169,8 +28537,8 @@ var ts;
                     write(";");
                 }
                 if (isClassExpressionWithStaticProperties) {
-                    for (var _a = 0; _a < staticProperties.length; _a++) {
-                        var property = staticProperties[_a];
+                    for (var _a = 0, staticProperties_1 = staticProperties; _a < staticProperties_1.length; _a++) {
+                        var property = staticProperties_1[_a];
                         write(",");
                         writeLine();
                         emitPropertyDeclaration(node, property, tempVariable, true);
@@ -28186,7 +28554,7 @@ var ts;
                     emitPropertyDeclarations(node, staticProperties);
                     emitDecoratorsOfClass(node);
                 }
-                if (!isES6ExportedDeclaration(node) && (node.flags & 1)) {
+                if (!isES6ExportedDeclaration(node) && (node.flags & 2)) {
                     writeLine();
                     emitStart(node);
                     emitModuleMemberName(node);
@@ -28195,7 +28563,7 @@ var ts;
                     emitEnd(node);
                     write(";");
                 }
-                else if (isES6ExportedDeclaration(node) && (node.flags & 1024) && thisNodeIsDecorated) {
+                else if (isES6ExportedDeclaration(node) && (node.flags & 512) && thisNodeIsDecorated) {
                     writeLine();
                     write("export default ");
                     emitDeclarationName(node);
@@ -28275,13 +28643,13 @@ var ts;
             }
             function emitClassMemberPrefix(node, member) {
                 emitDeclarationName(node);
-                if (!(member.flags & 128)) {
+                if (!(member.flags & 64)) {
                     write(".prototype");
                 }
             }
             function emitDecoratorsOfClass(node) {
                 emitDecoratorsOfMembers(node, 0);
-                emitDecoratorsOfMembers(node, 128);
+                emitDecoratorsOfMembers(node, 64);
                 emitDecoratorsOfConstructor(node);
             }
             function emitDecoratorsOfConstructor(node) {
@@ -28316,7 +28684,7 @@ var ts;
             function emitDecoratorsOfMembers(node, staticFlag) {
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
-                    if ((member.flags & 128) !== staticFlag) {
+                    if ((member.flags & 64) !== staticFlag) {
                         continue;
                     }
                     if (!ts.nodeCanBeDecorated(member)) {
@@ -28643,7 +29011,7 @@ var ts;
                     return;
                 }
                 if (!shouldHoistDeclarationInSystemJsModule(node)) {
-                    if (!(node.flags & 1) || isES6ExportedDeclaration(node)) {
+                    if (!(node.flags & 2) || isES6ExportedDeclaration(node)) {
                         emitStart(node);
                         if (isES6ExportedDeclaration(node)) {
                             write("export ");
@@ -28674,7 +29042,7 @@ var ts;
                 emitModuleMemberName(node);
                 write(" = {}));");
                 emitEnd(node);
-                if (!isES6ExportedDeclaration(node) && node.flags & 1 && !shouldHoistDeclarationInSystemJsModule(node)) {
+                if (!isES6ExportedDeclaration(node) && node.flags & 2 && !shouldHoistDeclarationInSystemJsModule(node)) {
                     writeLine();
                     emitStart(node);
                     write("var ");
@@ -28685,7 +29053,7 @@ var ts;
                     write(";");
                 }
                 if (modulekind !== 5 && node.parent === currentSourceFile) {
-                    if (modulekind === 4 && (node.flags & 1)) {
+                    if (modulekind === 4 && (node.flags & 2)) {
                         writeLine();
                         write(exportFunctionForFile + "(\"");
                         emitDeclarationName(node);
@@ -28787,7 +29155,7 @@ var ts;
                     scopeEmitEnd();
                 }
                 write(")(");
-                if ((node.flags & 1) && !isES6ExportedDeclaration(node)) {
+                if ((node.flags & 2) && !isES6ExportedDeclaration(node)) {
                     emit(node.name);
                     write(" = ");
                 }
@@ -28797,7 +29165,7 @@ var ts;
                 write(" = {}));");
                 emitEnd(node);
                 if (!isES6ExportedDeclaration(node) && node.name.kind === 69 && node.parent === currentSourceFile) {
-                    if (modulekind === 4 && (node.flags & 1)) {
+                    if (modulekind === 4 && (node.flags & 2)) {
                         writeLine();
                         write(exportFunctionForFile + "(\"");
                         emitDeclarationName(node);
@@ -28895,7 +29263,7 @@ var ts;
             }
             function emitExternalImportDeclaration(node) {
                 if (ts.contains(externalImports, node)) {
-                    var isExportedImport = node.kind === 221 && (node.flags & 1) !== 0;
+                    var isExportedImport = node.kind === 221 && (node.flags & 2) !== 0;
                     var namespaceDeclaration = getNamespaceDeclarationNode(node);
                     if (modulekind !== 2) {
                         emitLeadingComments(node);
@@ -28961,7 +29329,7 @@ var ts;
                             write("export ");
                             write("var ");
                         }
-                        else if (!(node.flags & 1)) {
+                        else if (!(node.flags & 2)) {
                             write("var ");
                         }
                     }
@@ -29049,8 +29417,8 @@ var ts;
             function emitExportOrImportSpecifierList(specifiers, shouldEmit) {
                 ts.Debug.assert(modulekind === 5);
                 var needsComma = false;
-                for (var _a = 0; _a < specifiers.length; _a++) {
-                    var specifier = specifiers[_a];
+                for (var _a = 0, specifiers_1 = specifiers; _a < specifiers_1.length; _a++) {
+                    var specifier = specifiers_1[_a];
                     if (shouldEmit(specifier)) {
                         if (needsComma) {
                             write(", ");
@@ -29184,8 +29552,8 @@ var ts;
                 }
                 writeLine();
                 var started = false;
-                for (var _a = 0; _a < externalImports.length; _a++) {
-                    var importNode = externalImports[_a];
+                for (var _a = 0, externalImports_1 = externalImports; _a < externalImports_1.length; _a++) {
+                    var importNode = externalImports_1[_a];
                     var skipNode = importNode.kind === 228 ||
                         (importNode.kind === 222 && !importNode.importClause);
                     if (skipNode) {
@@ -29210,8 +29578,8 @@ var ts;
                 }
                 if (!exportedDeclarations && ts.isEmpty(exportSpecifiers)) {
                     var hasExportDeclarationWithExportClause = false;
-                    for (var _a = 0; _a < externalImports.length; _a++) {
-                        var externalImport = externalImports[_a];
+                    for (var _a = 0, externalImports_2 = externalImports; _a < externalImports_2.length; _a++) {
+                        var externalImport = externalImports_2[_a];
                         if (externalImport.kind === 228 && externalImport.exportClause) {
                             hasExportDeclarationWithExportClause = true;
                             break;
@@ -29239,8 +29607,8 @@ var ts;
                         }
                     }
                 }
-                for (var _d = 0; _d < externalImports.length; _d++) {
-                    var externalImport = externalImports[_d];
+                for (var _d = 0, externalImports_3 = externalImports; _d < externalImports_3.length; _d++) {
+                    var externalImport = externalImports_3[_d];
                     if (externalImport.kind !== 228) {
                         continue;
                     }
@@ -29284,7 +29652,7 @@ var ts;
                     return exportStarFunction;
                 }
                 function writeExportedName(node) {
-                    if (node.kind !== 69 && node.flags & 1024) {
+                    if (node.kind !== 69 && node.flags & 512) {
                         return;
                     }
                     if (started) {
@@ -29337,7 +29705,7 @@ var ts;
                             emit(local);
                         }
                         var flags = ts.getCombinedNodeFlags(local.kind === 69 ? local.parent : local);
-                        if (flags & 1) {
+                        if (flags & 2) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -29347,11 +29715,11 @@ var ts;
                     write(";");
                 }
                 if (hoistedFunctionDeclarations) {
-                    for (var _a = 0; _a < hoistedFunctionDeclarations.length; _a++) {
-                        var f = hoistedFunctionDeclarations[_a];
+                    for (var _a = 0, hoistedFunctionDeclarations_1 = hoistedFunctionDeclarations; _a < hoistedFunctionDeclarations_1.length; _a++) {
+                        var f = hoistedFunctionDeclarations_1[_a];
                         writeLine();
                         emit(f);
-                        if (f.flags & 1) {
+                        if (f.flags & 2) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -29361,7 +29729,7 @@ var ts;
                 }
                 return exportedDeclarations;
                 function visit(node) {
-                    if (node.flags & 2) {
+                    if (node.flags & 4) {
                         return;
                     }
                     if (node.kind === 213) {
@@ -29431,7 +29799,7 @@ var ts;
                 if (checkIfSourceFileLevelDecl && !shouldHoistDeclarationInSystemJsModule(node)) {
                     return false;
                 }
-                return (ts.getCombinedNodeFlags(node) & 49152) === 0 ||
+                return (ts.getCombinedNodeFlags(node) & 24576) === 0 ||
                     ts.getEnclosingBlockScopeContainer(node).kind === 248;
             }
             function isCurrentFileSystemExternalModule() {
@@ -29466,8 +29834,8 @@ var ts;
                     var parameterName = makeUniqueName(ts.forEach(group, getLocalNameForExternalImport) || "");
                     write("function (" + parameterName + ") {");
                     increaseIndent();
-                    for (var _a = 0; _a < group.length; _a++) {
-                        var entry = group[_a];
+                    for (var _a = 0, group_1 = group; _a < group_1.length; _a++) {
+                        var entry = group_1[_a];
                         var importVariableName = getLocalNameForExternalImport(entry) || "";
                         switch (entry.kind) {
                             case 222:
@@ -29601,8 +29969,8 @@ var ts;
                         unaliasedModuleNames.push("\"" + amdDependency.path + "\"");
                     }
                 }
-                for (var _c = 0; _c < externalImports.length; _c++) {
-                    var importNode = externalImports[_c];
+                for (var _c = 0, externalImports_4 = externalImports; _c < externalImports_4.length; _c++) {
+                    var importNode = externalImports_4[_c];
                     var externalModuleName = getExternalModuleNameText(importNode);
                     var importAliasName = getLocalNameForExternalImport(importNode);
                     if (includeNonAmdDependencies && importAliasName) {
@@ -29855,7 +30223,7 @@ var ts;
             function emitSourceFileNode(node) {
                 writeLine();
                 emitShebang();
-                emitDetachedComments(node);
+                emitDetachedCommentsAndUpdateCommentsInfo(node);
                 if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
                     var emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[1];
                     emitModule(node);
@@ -29878,7 +30246,7 @@ var ts;
             }
             function emitNodeConsideringCommentsOption(node, emitNodeConsideringSourcemap) {
                 if (node) {
-                    if (node.flags & 2) {
+                    if (node.flags & 4) {
                         return emitCommentsOnNotEmittedNode(node);
                     }
                     if (isSpecializedCommentHandling(node)) {
@@ -30111,10 +30479,6 @@ var ts;
                 }
                 return leadingComments;
             }
-            function isPinnedComments(comment) {
-                return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 &&
-                    currentSourceFile.text.charCodeAt(comment.pos + 2) === 33;
-            }
             function isTripleSlashComment(comment) {
                 if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 47 &&
                     comment.pos + 2 < comment.end &&
@@ -30195,44 +30559,14 @@ var ts;
                 ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, { pos: pos, end: pos }, leadingComments);
                 ts.emitComments(currentSourceFile, writer, leadingComments, true, newLine, writeComment);
             }
-            function emitDetachedComments(node) {
-                var leadingComments;
-                if (compilerOptions.removeComments) {
-                    if (node.pos === 0) {
-                        leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComments);
+            function emitDetachedCommentsAndUpdateCommentsInfo(node) {
+                var currentDetachedCommentInfo = ts.emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, compilerOptions.removeComments);
+                if (currentDetachedCommentInfo) {
+                    if (detachedCommentsInfo) {
+                        detachedCommentsInfo.push(currentDetachedCommentInfo);
                     }
-                }
-                else {
-                    leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                }
-                if (leadingComments) {
-                    var detachedComments = [];
-                    var lastComment;
-                    ts.forEach(leadingComments, function (comment) {
-                        if (lastComment) {
-                            var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, lastComment.end);
-                            var commentLine = ts.getLineOfLocalPosition(currentSourceFile, comment.pos);
-                            if (commentLine >= lastCommentLine + 2) {
-                                return detachedComments;
-                            }
-                        }
-                        detachedComments.push(comment);
-                        lastComment = comment;
-                    });
-                    if (detachedComments.length) {
-                        var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
-                        var nodeLine = ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
-                        if (nodeLine >= lastCommentLine + 2) {
-                            ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
-                            ts.emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment);
-                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
-                            if (detachedCommentsInfo) {
-                                detachedCommentsInfo.push(currentDetachedCommentInfo);
-                            }
-                            else {
-                                detachedCommentsInfo = [currentDetachedCommentInfo];
-                            }
-                        }
+                    else {
+                        detachedCommentsInfo = [currentDetachedCommentInfo];
                     }
                 }
             }
@@ -30535,7 +30869,7 @@ var ts;
         var resolveModuleNamesWorker = host.resolveModuleNames
             ? (function (moduleNames, containingFile) { return host.resolveModuleNames(moduleNames, containingFile); })
             : (function (moduleNames, containingFile) { return ts.map(moduleNames, function (moduleName) { return resolveModuleName(moduleName, containingFile, options, host).resolvedModule; }); });
-        var filesByName = ts.createFileMap(getCanonicalFileName);
+        var filesByName = ts.createFileMap();
         var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createFileMap(function (fileName) { return fileName.toLowerCase(); }) : undefined;
         if (oldProgram) {
             var oldOptions = oldProgram.getCompilerOptions();
@@ -30583,8 +30917,8 @@ var ts;
             if (!classifiableNames) {
                 getTypeChecker();
                 classifiableNames = {};
-                for (var _i = 0; _i < files.length; _i++) {
-                    var sourceFile = files[_i];
+                for (var _i = 0, files_3 = files; _i < files_3.length; _i++) {
+                    var sourceFile = files_3[_i];
                     ts.copyMap(sourceFile.classifiableNames, classifiableNames);
                 }
             }
@@ -30600,7 +30934,7 @@ var ts;
                 return false;
             }
             var newSourceFiles = [];
-            var normalizedAbsoluteFileNames = [];
+            var filePaths = [];
             var modifiedSourceFiles = [];
             for (var _i = 0, _a = oldProgram.getSourceFiles(); _i < _a.length; _i++) {
                 var oldSourceFile = _a[_i];
@@ -30608,8 +30942,8 @@ var ts;
                 if (!newSourceFile) {
                     return false;
                 }
-                var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);
-                normalizedAbsoluteFileNames.push(normalizedAbsolutePath);
+                newSourceFile.path = oldSourceFile.path;
+                filePaths.push(newSourceFile.path);
                 if (oldSourceFile !== newSourceFile) {
                     if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
                         return false;
@@ -30623,7 +30957,7 @@ var ts;
                     }
                     if (resolveModuleNamesWorker) {
                         var moduleNames = ts.map(newSourceFile.imports, function (name) { return name.text; });
-                        var resolutions = resolveModuleNamesWorker(moduleNames, normalizedAbsolutePath);
+                        var resolutions = resolveModuleNamesWorker(moduleNames, ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));
                         for (var i = 0; i < moduleNames.length; ++i) {
                             var newResolution = resolutions[i];
                             var oldResolution = ts.getResolvedModule(oldSourceFile, moduleNames[i]);
@@ -30646,12 +30980,12 @@ var ts;
                 newSourceFiles.push(newSourceFile);
             }
             for (var i = 0, len = newSourceFiles.length; i < len; ++i) {
-                filesByName.set(normalizedAbsoluteFileNames[i], newSourceFiles[i]);
+                filesByName.set(filePaths[i], newSourceFiles[i]);
             }
             files = newSourceFiles;
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
-            for (var _b = 0; _b < modifiedSourceFiles.length; _b++) {
-                var modifiedFile = modifiedSourceFiles[_b];
+            for (var _b = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _b < modifiedSourceFiles_1.length; _b++) {
+                var modifiedFile = modifiedSourceFiles_1[_b];
                 fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);
             }
             oldProgram.structureIsReused = true;
@@ -30690,7 +31024,7 @@ var ts;
             return emitResult;
         }
         function getSourceFile(fileName) {
-            return filesByName.get(ts.getNormalizedAbsolutePath(fileName, currentDirectory));
+            return filesByName.get(ts.toPath(fileName, currentDirectory, getCanonicalFileName));
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) {
             if (sourceFile) {
@@ -30799,7 +31133,7 @@ var ts;
                         }
                         break;
                     case 218:
-                        if (node.name.kind === 9 && (node.flags & 2 || ts.isDeclarationFile(file))) {
+                        if (node.name.kind === 9 && (node.flags & 4 || ts.isDeclarationFile(file))) {
                             ts.forEachChild(node.body, function (node) {
                                 collect(node, false);
                             });
@@ -30816,7 +31150,7 @@ var ts;
                     diagnostic = ts.Diagnostics.File_0_has_unsupported_extension_The_only_supported_extensions_are_1;
                     diagnosticArgument = [fileName, "'" + ts.supportedExtensions.join("', '") + "'"];
                 }
-                else if (!findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd)) {
+                else if (!findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd)) {
                     diagnostic = ts.Diagnostics.File_0_not_found;
                     diagnosticArgument = [fileName];
                 }
@@ -30826,13 +31160,13 @@ var ts;
                 }
             }
             else {
-                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd);
+                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd);
                 if (!nonTsFile) {
                     if (options.allowNonTsExtensions) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         diagnosticArgument = [fileName];
                     }
-                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.getNormalizedAbsolutePath(fileName + extension, currentDirectory), isDefaultLib, refFile, refPos, refEnd); })) {
+                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.toPath(fileName + extension, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd); })) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         fileName += ".ts";
                         diagnosticArgument = [fileName];
@@ -30874,6 +31208,7 @@ var ts;
             });
             filesByName.set(normalizedAbsolutePath, file);
             if (file) {
+                file.path = normalizedAbsolutePath;
                 if (host.useCaseSensitiveFileNames()) {
                     var existingFile = filesByNameIgnoreCase.get(normalizedAbsolutePath);
                     if (existingFile) {
@@ -30918,11 +31253,7 @@ var ts;
                     var resolution = resolutions[i];
                     ts.setResolvedModule(file, moduleNames[i], resolution);
                     if (resolution && !options.noResolve) {
-                        var absoluteImportPath = ts.isRootedDiskPath(resolution.resolvedFileName)
-                            ? resolution.resolvedFileName
-                            : ts.getNormalizedAbsolutePath(resolution.resolvedFileName, currentDirectory);
-                        var relativePath = ts.getRelativePathToDirectoryOrUrl(currentDirectory, absoluteImportPath, currentDirectory, getCanonicalFileName, false);
-                        var importedFile = findSourceFile(relativePath, absoluteImportPath, false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
+                        var importedFile = findSourceFile(resolution.resolvedFileName, ts.toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!ts.isExternalModule(importedFile)) {
                                 var start_2 = ts.getTokenPosOfNode(file.imports[i], file);
@@ -30973,8 +31304,8 @@ var ts;
             var allFilesBelongToPath = true;
             if (sourceFiles) {
                 var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) {
+                    var sourceFile = sourceFiles_1[_i];
                     if (!ts.isDeclarationFile(sourceFile)) {
                         var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
                         if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
@@ -31231,6 +31562,12 @@ var ts;
             type: "boolean",
             description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
         },
+        {
+            name: "pretty",
+            paramType: ts.Diagnostics.KIND,
+            description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
         {
             name: "project",
             shortName: "p",
@@ -31329,11 +31666,31 @@ var ts;
             description: ts.Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
             error: ts.Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic
         },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
         {
             name: "forceConsistentCasingInFileNames",
             type: "boolean",
             description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
-        },
+        }
     ];
     var optionNameMapCache;
     function getOptionNameMap() {
@@ -31459,13 +31816,31 @@ var ts;
     ts.readConfigFile = readConfigFile;
     function parseConfigFileTextToJson(fileName, jsonText) {
         try {
-            return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
+            var jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
         }
         catch (e) {
             return { error: ts.createCompilerDiagnostic(ts.Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
         }
     }
     ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
+    function removeComments(jsonText) {
+        var output = "";
+        var scanner = ts.createScanner(1, false, 0, jsonText);
+        var token;
+        while ((token = scanner.scan()) !== 1) {
+            switch (token) {
+                case 2:
+                case 3:
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
     function parseJsonConfigFileContent(json, host, basePath) {
         var _a = convertCompilerOptionsFromJson(json["compilerOptions"], basePath), options = _a.options, errors = _a.errors;
         return {
@@ -31554,6 +31929,13 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
+    var reportDiagnostic = reportDiagnosticSimply;
+    function reportDiagnostics(diagnostics, host) {
+        for (var _i = 0, diagnostics_1 = diagnostics; _i < diagnostics_1.length; _i++) {
+            var diagnostic = diagnostics_1[_i];
+            reportDiagnostic(diagnostic, host);
+        }
+    }
     function validateLocaleAndSetLanguage(locale, errors) {
         var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase());
         if (!matchResult) {
@@ -31612,20 +31994,84 @@ var ts;
         var diagnostic = ts.createCompilerDiagnostic.apply(undefined, arguments);
         return diagnostic.messageText;
     }
-    function reportDiagnostic(diagnostic) {
+    function reportDiagnosticSimply(diagnostic, host) {
         var output = "";
         if (diagnostic.file) {
-            var loc = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-            output += diagnostic.file.fileName + "(" + (loc.line + 1) + "," + (loc.character + 1) + "): ";
+            var _a = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), line = _a.line, character = _a.character;
+            var relativeFileName = host
+                ? ts.convertToRelativePath(diagnostic.file.fileName, host.getCurrentDirectory(), function (fileName) { return host.getCanonicalFileName(fileName); })
+                : diagnostic.file.fileName;
+            output += diagnostic.file.fileName + "(" + (line + 1) + "," + (character + 1) + "): ";
         }
         var category = ts.DiagnosticCategory[diagnostic.category].toLowerCase();
         output += category + " TS" + diagnostic.code + ": " + ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine) + ts.sys.newLine;
         ts.sys.write(output);
     }
-    function reportDiagnostics(diagnostics) {
-        for (var i = 0; i < diagnostics.length; i++) {
-            reportDiagnostic(diagnostics[i]);
+    var redForegroundEscapeSequence = "\u001b[91m";
+    var yellowForegroundEscapeSequence = "\u001b[93m";
+    var blueForegroundEscapeSequence = "\u001b[93m";
+    var gutterStyleSequence = "\u001b[100;30m";
+    var gutterSeparator = " ";
+    var resetEscapeSequence = "\u001b[0m";
+    var elipsis = "...";
+    var categoryFormatMap = (_a = {},
+        _a[ts.DiagnosticCategory.Warning] = yellowForegroundEscapeSequence,
+        _a[ts.DiagnosticCategory.Error] = redForegroundEscapeSequence,
+        _a[ts.DiagnosticCategory.Message] = blueForegroundEscapeSequence,
+        _a
+    );
+    function formatAndReset(text, formatStyle) {
+        return formatStyle + text + resetEscapeSequence;
+    }
+    function reportDiagnosticWithColorAndContext(diagnostic, host) {
+        var output = "";
+        if (diagnostic.file) {
+            var start = diagnostic.start, length_3 = diagnostic.length, file = diagnostic.file;
+            var _a = ts.getLineAndCharacterOfPosition(file, start), firstLine = _a.line, firstLineChar = _a.character;
+            var _b = ts.getLineAndCharacterOfPosition(file, start + length_3), lastLine = _b.line, lastLineChar = _b.character;
+            var lastLineInFile = ts.getLineAndCharacterOfPosition(file, file.text.length).line;
+            var hasMoreThanFiveLines = (lastLine - firstLine) >= 4;
+            var gutterWidth = (lastLine + 1 + "").length;
+            if (hasMoreThanFiveLines) {
+                gutterWidth = Math.max(elipsis.length, gutterWidth);
+            }
+            output += ts.sys.newLine;
+            for (var i = firstLine; i <= lastLine; i++) {
+                if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
+                    output += formatAndReset(padLeft(elipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + ts.sys.newLine;
+                    i = lastLine - 1;
+                }
+                var lineStart = ts.getPositionOfLineAndCharacter(file, i, 0);
+                var lineEnd = i < lastLineInFile ? ts.getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;
+                var lineContent = file.text.slice(lineStart, lineEnd);
+                lineContent = lineContent.replace(/\s+$/g, "");
+                lineContent = lineContent.replace("\t", " ");
+                output += formatAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;
+                output += lineContent + ts.sys.newLine;
+                output += formatAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;
+                output += redForegroundEscapeSequence;
+                if (i === firstLine) {
+                    var lastCharForLine = i === lastLine ? lastLineChar : undefined;
+                    output += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
+                    output += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");
+                }
+                else if (i === lastLine) {
+                    output += lineContent.slice(0, lastLineChar).replace(/./g, "~");
+                }
+                else {
+                    output += lineContent.replace(/./g, "~");
+                }
+                output += resetEscapeSequence;
+                output += ts.sys.newLine;
+            }
+            output += ts.sys.newLine;
+            output += file.fileName + "(" + (firstLine + 1) + "," + (firstLineChar + 1) + "): ";
         }
+        var categoryColor = categoryFormatMap[diagnostic.category];
+        var category = ts.DiagnosticCategory[diagnostic.category].toLowerCase();
+        output += formatAndReset(category, categoryColor) + " TS" + diagnostic.code + ": " + ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine);
+        output += ts.sys.newLine + ts.sys.newLine;
+        ts.sys.write(output);
     }
     function reportWatchDiagnostic(diagnostic) {
         var output = new Date().toLocaleTimeString() + " - ";
@@ -31677,13 +32123,13 @@ var ts;
         var hostFileExists;
         if (commandLine.options.locale) {
             if (!isJSONSupported()) {
-                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"));
+                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"), undefined);
                 return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             validateLocaleAndSetLanguage(commandLine.options.locale, commandLine.errors);
         }
         if (commandLine.errors.length > 0) {
-            reportDiagnostics(commandLine.errors);
+            reportDiagnostics(commandLine.errors, compilerHost);
             return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
         }
         if (commandLine.options.init) {
@@ -31691,7 +32137,7 @@ var ts;
             return ts.sys.exit(ts.ExitStatus.Success);
         }
         if (commandLine.options.version) {
-            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Version_0, ts.version));
+            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Version_0, ts.version), undefined);
             return ts.sys.exit(ts.ExitStatus.Success);
         }
         if (commandLine.options.help) {
@@ -31701,12 +32147,12 @@ var ts;
         }
         if (commandLine.options.project) {
             if (!isJSONSupported()) {
-                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--project"));
+                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--project"), undefined);
                 return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             configFileName = ts.normalizePath(ts.combinePaths(commandLine.options.project, "tsconfig.json"));
             if (commandLine.fileNames.length !== 0) {
-                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line));
+                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line), undefined);
                 return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
         }
@@ -31721,7 +32167,7 @@ var ts;
         }
         if (commandLine.options.watch && commandLine.options.hasOwnProperty("watch")) {
             if (!ts.sys.watchFile) {
-                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"));
+                reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"), undefined);
                 return ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             if (configFileName) {
@@ -31749,7 +32195,7 @@ var ts;
             var configObject = result.config;
             var configParseResult = ts.parseJsonConfigFileContent(configObject, ts.sys, ts.getDirectoryPath(configFileName));
             if (configParseResult.errors.length > 0) {
-                reportDiagnostics(configParseResult.errors);
+                reportDiagnostics(configParseResult.errors, undefined);
                 ts.sys.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped);
                 return;
             }
@@ -31772,6 +32218,9 @@ var ts;
                 hostFileExists = compilerHost.fileExists;
                 compilerHost.fileExists = cachedFileExists;
             }
+            if (compilerOptions.pretty) {
+                reportDiagnostic = reportDiagnosticWithColorAndContext;
+            }
             cachedExistingFiles = {};
             var compileResult = compile(rootFileNames, compilerOptions, compilerHost);
             if (!compilerOptions.watch) {
@@ -31906,14 +32355,14 @@ var ts;
                     diagnostics = program.getSemanticDiagnostics();
                 }
             }
-            reportDiagnostics(diagnostics);
+            reportDiagnostics(diagnostics, compilerHost);
             if (compilerOptions.noEmit) {
                 return diagnostics.length
                     ? ts.ExitStatus.DiagnosticsPresent_OutputsSkipped
                     : ts.ExitStatus.Success;
             }
             var emitOutput = program.emit();
-            reportDiagnostics(emitOutput.diagnostics);
+            reportDiagnostics(emitOutput.diagnostics, compilerHost);
             if (emitOutput.emitSkipped) {
                 return ts.ExitStatus.DiagnosticsPresent_OutputsSkipped;
             }
@@ -31988,7 +32437,7 @@ var ts;
         var currentDirectory = ts.sys.getCurrentDirectory();
         var file = ts.normalizePath(ts.combinePaths(currentDirectory, "tsconfig.json"));
         if (ts.sys.fileExists(file)) {
-            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file));
+            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), undefined);
         }
         else {
             var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions);
@@ -32000,7 +32449,7 @@ var ts;
                 configurations.files = fileNames;
             }
             ts.sys.writeFile(file, JSON.stringify(configurations, undefined, 4));
-            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Successfully_created_a_tsconfig_json_file));
+            reportDiagnostic(ts.createCompilerDiagnostic(ts.Diagnostics.Successfully_created_a_tsconfig_json_file), undefined);
         }
         return;
         function serializeCompilerOptions(options) {
@@ -32039,5 +32488,6 @@ var ts;
             return result;
         }
     }
+    var _a;
 })(ts || (ts = {}));
 ts.executeCommandLine(ts.sys.args);
diff --git a/lib/tsserver.js b/lib/tsserver.js
index ed62dd90686..2893dab82ef 100644
--- a/lib/tsserver.js
+++ b/lib/tsserver.js
@@ -49,40 +49,49 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
-    function createFileMap(getCanonicalFileName) {
+    function createFileMap(keyMapper) {
         var files = {};
         return {
             get: get,
             set: set,
             contains: contains,
             remove: remove,
-            clear: clear,
-            forEachValue: forEachValueInMap
+            forEachValue: forEachValueInMap,
+            clear: clear
         };
-        function set(fileName, value) {
-            files[normalizeKey(fileName)] = value;
-        }
-        function get(fileName) {
-            return files[normalizeKey(fileName)];
-        }
-        function contains(fileName) {
-            return hasProperty(files, normalizeKey(fileName));
-        }
-        function remove(fileName) {
-            var key = normalizeKey(fileName);
-            delete files[key];
-        }
         function forEachValueInMap(f) {
-            forEachValue(files, f);
+            for (var key in files) {
+                f(key, files[key]);
+            }
         }
-        function normalizeKey(key) {
-            return getCanonicalFileName(normalizeSlashes(key));
+        function get(path) {
+            return files[toKey(path)];
+        }
+        function set(path, value) {
+            files[toKey(path)] = value;
+        }
+        function contains(path) {
+            return hasProperty(files, toKey(path));
+        }
+        function remove(path) {
+            var key = toKey(path);
+            delete files[key];
         }
         function clear() {
             files = {};
         }
+        function toKey(path) {
+            return keyMapper ? keyMapper(path) : path;
+        }
     }
     ts.createFileMap = createFileMap;
+    function toPath(fileName, basePath, getCanonicalFileName) {
+        var nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return getCanonicalFileName(nonCanonicalizedPath);
+    }
+    ts.toPath = toPath;
     function forEach(array, callback) {
         if (array) {
             for (var i = 0, len = array.length; i < len; i++) {
@@ -97,8 +106,8 @@ var ts;
     ts.forEach = forEach;
     function contains(array, value) {
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+                var v = array_1[_i];
                 if (v === value) {
                     return true;
                 }
@@ -121,8 +130,8 @@ var ts;
     function countWhere(array, predicate) {
         var count = 0;
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
+                var v = array_2[_i];
                 if (predicate(v)) {
                     count++;
                 }
@@ -135,8 +144,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
+                var item = array_3[_i];
                 if (f(item)) {
                     result.push(item);
                 }
@@ -149,8 +158,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
+                var v = array_4[_i];
                 result.push(f(v));
             }
         }
@@ -169,8 +178,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
+                var item = array_5[_i];
                 if (!contains(result, item)) {
                     result.push(item);
                 }
@@ -181,8 +190,8 @@ var ts;
     ts.deduplicate = deduplicate;
     function sum(array, prop) {
         var result = 0;
-        for (var _i = 0; _i < array.length; _i++) {
-            var v = array[_i];
+        for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
+            var v = array_6[_i];
             result += v[prop];
         }
         return result;
@@ -190,8 +199,8 @@ var ts;
     ts.sum = sum;
     function addRange(to, from) {
         if (to && from) {
-            for (var _i = 0; _i < from.length; _i++) {
-                var v = from[_i];
+            for (var _i = 0, from_1 = from; _i < from_1.length; _i++) {
+                var v = from_1[_i];
                 to.push(v);
             }
         }
@@ -512,8 +521,8 @@ var ts;
     function getNormalizedParts(normalizedSlashedPath, rootLength) {
         var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator);
         var normalized = [];
-        for (var _i = 0; _i < parts.length; _i++) {
-            var part = parts[_i];
+        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+            var part = parts_1[_i];
             if (part !== ".") {
                 if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
@@ -661,8 +670,8 @@ var ts;
         if (!fileName) {
             return false;
         }
-        for (var _i = 0; _i < ts.supportedExtensions.length; _i++) {
-            var extension = ts.supportedExtensions[_i];
+        for (var _i = 0, supportedExtensions_1 = ts.supportedExtensions; _i < supportedExtensions_1.length; _i++) {
+            var extension = supportedExtensions_1[_i];
             if (fileExtensionIs(fileName, extension)) {
                 return true;
             }
@@ -672,8 +681,8 @@ var ts;
     ts.isSupportedSourceFileName = isSupportedSourceFileName;
     var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     function removeFileExtension(path) {
-        for (var _i = 0; _i < extensionsToRemove.length; _i++) {
-            var ext = extensionsToRemove[_i];
+        for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
+            var ext = extensionsToRemove_1[_i];
             if (fileExtensionIs(path, ext)) {
                 return path.substr(0, path.length - ext.length);
             }
@@ -747,8 +756,8 @@ var ts;
     })(Debug = ts.Debug || (ts.Debug = {}));
     function copyListRemovingItem(item, list) {
         var copiedList = [];
-        for (var _i = 0; _i < list.length; _i++) {
-            var e = list[_i];
+        for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+            var e = list_1[_i];
             if (e !== item) {
                 copiedList.push(e);
             }
@@ -834,16 +843,16 @@ var ts;
                 function visitDirectory(path) {
                     var folder = fso.GetFolder(path || ".");
                     var files = getNames(folder.files);
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        var current = files_1[_i];
                         var name_1 = ts.combinePaths(path, current);
                         if ((!extension || ts.fileExtensionIs(name_1, extension)) && !ts.contains(exclude, getCanonicalPath(name_1))) {
                             result.push(name_1);
                         }
                     }
                     var subfolders = getNames(folder.subfolders);
-                    for (var _a = 0; _a < subfolders.length; _a++) {
-                        var current = subfolders[_a];
+                    for (var _a = 0, subfolders_1 = subfolders; _a < subfolders_1.length; _a++) {
+                        var current = subfolders_1[_a];
                         var name_2 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_2))) {
                             visitDirectory(name_2);
@@ -894,6 +903,7 @@ var ts;
             var _fs = require("fs");
             var _path = require("path");
             var _os = require("os");
+            var _tty = require("tty");
             function createWatchedFileSet(interval, chunkSize) {
                 if (interval === void 0) { interval = 2500; }
                 if (chunkSize === void 0) { chunkSize = 30; }
@@ -1006,8 +1016,8 @@ var ts;
                 function visitDirectory(path) {
                     var files = _fs.readdirSync(path || ".").sort();
                     var directories = [];
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_2 = files; _i < files_2.length; _i++) {
+                        var current = files_2[_i];
                         var name_3 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_3))) {
                             var stat = _fs.statSync(name_3);
@@ -1021,8 +1031,8 @@ var ts;
                             }
                         }
                     }
-                    for (var _a = 0; _a < directories.length; _a++) {
-                        var current = directories[_a];
+                    for (var _a = 0, directories_1 = directories; _a < directories_1.length; _a++) {
+                        var current = directories_1[_a];
                         visitDirectory(current);
                     }
                 }
@@ -1032,14 +1042,7 @@ var ts;
                 newLine: _os.EOL,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 write: function (s) {
-                    var buffer = new Buffer(s, "utf8");
-                    var offset = 0;
-                    var toWrite = buffer.length;
-                    var written = 0;
-                    while ((written = _fs.writeSync(1, buffer, offset, toWrite)) < toWrite) {
-                        offset += written;
-                        toWrite -= written;
-                    }
+                    process.stdout.write(s);
                 },
                 readFile: readFile,
                 writeFile: writeFile,
@@ -1306,6 +1309,7 @@ var ts;
         await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: ts.DiagnosticCategory.Error, key: "await_expression_is_only_allowed_within_an_async_function_1308", message: "'await' expression is only allowed within an async function." },
         Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: ts.DiagnosticCategory.Error, key: "Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher_1311", message: "Async functions are only available when targeting ECMAScript 6 and higher." },
         can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: { code: 1312, category: ts.DiagnosticCategory.Error, key: "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", message: "'=' can only be used in an object literal property inside a destructuring assignment." },
+        The_body_of_an_if_statement_cannot_be_the_empty_statement: { code: 1313, category: ts.DiagnosticCategory.Error, key: "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", message: "The body of an 'if' statement cannot be the empty statement." },
         Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_2300", message: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.DiagnosticCategory.Error, key: "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", message: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: ts.DiagnosticCategory.Error, key: "Static_members_cannot_reference_class_type_parameters_2302", message: "Static members cannot reference class type parameters." },
@@ -1358,7 +1362,7 @@ var ts;
         Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: ts.DiagnosticCategory.Error, key: "Neither_type_0_nor_type_1_is_assignable_to_the_other_2352", message: "Neither type '{0}' nor type '{1}' is assignable to the other." },
         Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: ts.DiagnosticCategory.Error, key: "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", message: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
         No_best_common_type_exists_among_return_expressions: { code: 2354, category: ts.DiagnosticCategory.Error, key: "No_best_common_type_exists_among_return_expressions_2354", message: "No best common type exists among return expressions." },
-        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_th_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." },
+        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value." },
         An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: ts.DiagnosticCategory.Error, key: "An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type_2356", message: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
         The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: ts.DiagnosticCategory.Error, key: "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer_2357", message: "The operand of an increment or decrement operator must be a variable, property or indexer." },
         The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", message: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." },
@@ -1379,7 +1383,7 @@ var ts;
         Duplicate_number_index_signature: { code: 2375, category: ts.DiagnosticCategory.Error, key: "Duplicate_number_index_signature_2375", message: "Duplicate number index signature." },
         A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: ts.DiagnosticCategory.Error, key: "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", message: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." },
         Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: ts.DiagnosticCategory.Error, key: "Constructors_for_derived_classes_must_contain_a_super_call_2377", message: "Constructors for derived classes must contain a 'super' call." },
-        A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement_2378", message: "A 'get' accessor must return a value or consist of a single 'throw' statement." },
+        A_get_accessor_must_return_a_value: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_2378", message: "A 'get' accessor must return a value." },
         Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: ts.DiagnosticCategory.Error, key: "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", message: "Getter and setter accessors do not agree in visibility." },
         get_and_set_accessor_must_have_the_same_type: { code: 2380, category: ts.DiagnosticCategory.Error, key: "get_and_set_accessor_must_have_the_same_type_2380", message: "'get' and 'set' accessor must have the same type." },
         A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: ts.DiagnosticCategory.Error, key: "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", message: "A signature with an implementation cannot use a string literal type." },
@@ -1669,8 +1673,6 @@ var ts;
         NEWLINE: { code: 6061, category: ts.DiagnosticCategory.Message, key: "NEWLINE_6061", message: "NEWLINE" },
         Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: ts.DiagnosticCategory.Error, key: "Argument_for_newLine_option_must_be_CRLF_or_LF_6062", message: "Argument for '--newLine' option must be 'CRLF' or 'LF'." },
         Argument_for_moduleResolution_option_must_be_node_or_classic: { code: 6063, category: ts.DiagnosticCategory.Error, key: "Argument_for_moduleResolution_option_must_be_node_or_classic_6063", message: "Argument for '--moduleResolution' option must be 'node' or 'classic'." },
-        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
-        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Enables_experimental_support_for_ES7_decorators: { code: 6065, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_decorators_6065", message: "Enables experimental support for ES7 decorators." },
         Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", message: "Enables experimental support for emitting type metadata for decorators." },
         Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_async_functions_6068", message: "Enables experimental support for ES7 async functions." },
@@ -1678,7 +1680,14 @@ var ts;
         Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: ts.DiagnosticCategory.Message, key: "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", message: "Initializes a TypeScript project and creates a tsconfig.json file." },
         Successfully_created_a_tsconfig_json_file: { code: 6071, category: ts.DiagnosticCategory.Message, key: "Successfully_created_a_tsconfig_json_file_6071", message: "Successfully created a tsconfig.json file." },
         Suppress_excess_property_checks_for_object_literals: { code: 6072, category: ts.DiagnosticCategory.Message, key: "Suppress_excess_property_checks_for_object_literals_6072", message: "Suppress excess property checks for object literals." },
-        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6073", message: "Disallow inconsistently-cased references to the same file." },
+        Stylize_errors_and_messages_using_color_and_context_experimental: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Stylize_errors_and_messages_using_color_and_context_experimental_6073", message: "Stylize errors and messages using color and context. (experimental)" },
+        Do_not_report_errors_on_unused_labels: { code: 6074, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unused_labels_6074", message: "Do not report errors on unused labels." },
+        Report_error_when_not_all_code_paths_in_function_return_a_value: { code: 6075, category: ts.DiagnosticCategory.Message, key: "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", message: "Report error when not all code paths in function return a value." },
+        Report_errors_for_fallthrough_cases_in_switch_statement: { code: 6076, category: ts.DiagnosticCategory.Message, key: "Report_errors_for_fallthrough_cases_in_switch_statement_6076", message: "Report errors for fallthrough cases in switch statement." },
+        Do_not_report_errors_on_unreachable_code: { code: 6077, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unreachable_code_6077", message: "Do not report errors on unreachable code." },
+        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6078, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6078", message: "Disallow inconsistently-cased references to the same file." },
+        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
+        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Variable_0_implicitly_has_an_1_type: { code: 7005, category: ts.DiagnosticCategory.Error, key: "Variable_0_implicitly_has_an_1_type_7005", message: "Variable '{0}' implicitly has an '{1}' type." },
         Parameter_0_implicitly_has_an_1_type: { code: 7006, category: ts.DiagnosticCategory.Error, key: "Parameter_0_implicitly_has_an_1_type_7006", message: "Parameter '{0}' implicitly has an '{1}' type." },
         Member_0_implicitly_has_an_1_type: { code: 7008, category: ts.DiagnosticCategory.Error, key: "Member_0_implicitly_has_an_1_type_7008", message: "Member '{0}' implicitly has an '{1}' type." },
@@ -1696,6 +1705,10 @@ var ts;
         Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: ts.DiagnosticCategory.Error, key: "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", message: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
         Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: ts.DiagnosticCategory.Error, key: "Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_typ_7025", message: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
         JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: ts.DiagnosticCategory.Error, key: "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", message: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
+        Unreachable_code_detected: { code: 7027, category: ts.DiagnosticCategory.Error, key: "Unreachable_code_detected_7027", message: "Unreachable code detected." },
+        Unused_label: { code: 7028, category: ts.DiagnosticCategory.Error, key: "Unused_label_7028", message: "Unused label." },
+        Fallthrough_case_in_switch: { code: 7029, category: ts.DiagnosticCategory.Error, key: "Fallthrough_case_in_switch_7029", message: "Fallthrough case in switch." },
+        Not_all_code_paths_return_a_value: { code: 7030, category: ts.DiagnosticCategory.Error, key: "Not_all_code_paths_return_a_value_7030", message: "Not all code paths return a value." },
         You_cannot_rename_this_element: { code: 8000, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_this_element_8000", message: "You cannot rename this element." },
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", message: "You cannot rename elements that are defined in the standard TypeScript library." },
         import_can_only_be_used_in_a_ts_file: { code: 8002, category: ts.DiagnosticCategory.Error, key: "import_can_only_be_used_in_a_ts_file_8002", message: "'import ... =' can only be used in a .ts file." },
@@ -3225,6 +3238,12 @@ var ts;
             type: "boolean",
             description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
         },
+        {
+            name: "pretty",
+            paramType: ts.Diagnostics.KIND,
+            description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
         {
             name: "project",
             shortName: "p",
@@ -3323,11 +3342,31 @@ var ts;
             description: ts.Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
             error: ts.Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic
         },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
         {
             name: "forceConsistentCasingInFileNames",
             type: "boolean",
             description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
-        },
+        }
     ];
     var optionNameMapCache;
     function getOptionNameMap() {
@@ -3453,13 +3492,31 @@ var ts;
     ts.readConfigFile = readConfigFile;
     function parseConfigFileTextToJson(fileName, jsonText) {
         try {
-            return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
+            var jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
         }
         catch (e) {
             return { error: ts.createCompilerDiagnostic(ts.Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
         }
     }
     ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
+    function removeComments(jsonText) {
+        var output = "";
+        var scanner = ts.createScanner(1, false, 0, jsonText);
+        var token;
+        while ((token = scanner.scan()) !== 1) {
+            switch (token) {
+                case 2:
+                case 3:
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
     function parseJsonConfigFileContent(json, host, basePath) {
         var _a = convertCompilerOptionsFromJson(json["compilerOptions"], basePath), options = _a.options, errors = _a.errors;
         return {
@@ -3551,8 +3608,8 @@ var ts;
     function getDeclarationOfKind(symbol, kind) {
         var declarations = symbol.declarations;
         if (declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) {
+                var declaration = declarations_1[_i];
                 if (declaration.kind === kind) {
                     return declaration;
                 }
@@ -3722,7 +3779,7 @@ var ts;
     }
     ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName;
     function isBlockOrCatchScoped(declaration) {
-        return (getCombinedNodeFlags(declaration) & 49152) !== 0 ||
+        return (getCombinedNodeFlags(declaration) & 24576) !== 0 ||
             isCatchClauseVariableDeclaration(declaration);
     }
     ts.isBlockOrCatchScoped = isBlockOrCatchScoped;
@@ -3823,7 +3880,7 @@ var ts;
     }
     ts.isExternalModule = isExternalModule;
     function isDeclarationFile(file) {
-        return (file.flags & 8192) !== 0;
+        return (file.flags & 4096) !== 0;
     }
     ts.isDeclarationFile = isDeclarationFile;
     function isConstEnumDeclaration(node) {
@@ -3853,11 +3910,11 @@ var ts;
     }
     ts.getCombinedNodeFlags = getCombinedNodeFlags;
     function isConst(node) {
-        return !!(getCombinedNodeFlags(node) & 32768);
+        return !!(getCombinedNodeFlags(node) & 16384);
     }
     ts.isConst = isConst;
     function isLet(node) {
-        return !!(getCombinedNodeFlags(node) & 16384);
+        return !!(getCombinedNodeFlags(node) & 8192);
     }
     ts.isLet = isLet;
     function isPrologueDirective(node) {
@@ -4036,27 +4093,28 @@ var ts;
     }
     ts.isClassLike = isClassLike;
     function isFunctionLike(node) {
-        if (node) {
-            switch (node.kind) {
-                case 144:
-                case 173:
-                case 213:
-                case 174:
-                case 143:
-                case 142:
-                case 145:
-                case 146:
-                case 147:
-                case 148:
-                case 149:
-                case 152:
-                case 153:
-                    return true;
-            }
-        }
-        return false;
+        return node && isFunctionLikeKind(node.kind);
     }
     ts.isFunctionLike = isFunctionLike;
+    function isFunctionLikeKind(kind) {
+        switch (kind) {
+            case 144:
+            case 173:
+            case 213:
+            case 174:
+            case 143:
+            case 142:
+            case 145:
+            case 146:
+            case 147:
+            case 148:
+            case 149:
+            case 152:
+            case 153:
+                return true;
+        }
+    }
+    ts.isFunctionLikeKind = isFunctionLikeKind;
     function introducesArgumentsExoticObject(node) {
         switch (node.kind) {
             case 143:
@@ -4520,9 +4578,18 @@ var ts;
         return !!node && (node.kind === 162 || node.kind === 161);
     }
     ts.isBindingPattern = isBindingPattern;
+    function isNodeDescendentOf(node, ancestor) {
+        while (node) {
+            if (node === ancestor)
+                return true;
+            node = node.parent;
+        }
+        return false;
+    }
+    ts.isNodeDescendentOf = isNodeDescendentOf;
     function isInAmbientContext(node) {
         while (node) {
-            if (node.flags & (2 | 8192)) {
+            if (node.flags & (4 | 4096)) {
                 return true;
             }
             node = node.parent;
@@ -4580,7 +4647,7 @@ var ts;
             case 207:
             case 204:
             case 206:
-            case 98:
+            case 208:
             case 209:
             case 193:
             case 198:
@@ -4679,8 +4746,8 @@ var ts;
     ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes;
     function getHeritageClause(clauses, kind) {
         if (clauses) {
-            for (var _i = 0; _i < clauses.length; _i++) {
-                var clause = clauses[_i];
+            for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) {
+                var clause = clauses_1[_i];
                 if (clause.token === kind) {
                     return clause;
                 }
@@ -4692,7 +4759,6 @@ var ts;
     function tryResolveScriptReference(host, sourceFile, reference) {
         if (!host.getCompilerOptions().noResolve) {
             var referenceFileName = ts.isRootedDiskPath(reference.fileName) ? reference.fileName : ts.combinePaths(ts.getDirectoryPath(sourceFile.fileName), reference.fileName);
-            referenceFileName = ts.getNormalizedAbsolutePath(referenceFileName, host.getCurrentDirectory());
             return host.getSourceFile(referenceFileName);
         }
     }
@@ -4750,7 +4816,7 @@ var ts;
     }
     ts.isTrivia = isTrivia;
     function isAsyncFunctionLike(node) {
-        return isFunctionLike(node) && (node.flags & 512) !== 0 && !isAccessor(node);
+        return isFunctionLike(node) && (node.flags & 256) !== 0 && !isAccessor(node);
     }
     ts.isAsyncFunctionLike = isAsyncFunctionLike;
     function hasDynamicName(declaration) {
@@ -5108,7 +5174,7 @@ var ts;
         else {
             ts.forEach(declarations, function (member) {
                 if ((member.kind === 145 || member.kind === 146)
-                    && (member.flags & 128) === (accessor.flags & 128)) {
+                    && (member.flags & 64) === (accessor.flags & 64)) {
                     var memberName = getPropertyNameForPropertyNameNode(member.name);
                     var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
                     if (memberName === accessorName) {
@@ -5163,6 +5229,49 @@ var ts;
         });
     }
     ts.emitComments = emitComments;
+    function emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, removeComments) {
+        var leadingComments;
+        var currentDetachedCommentInfo;
+        if (removeComments) {
+            if (node.pos === 0) {
+                leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComment);
+            }
+        }
+        else {
+            leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
+        }
+        if (leadingComments) {
+            var detachedComments = [];
+            var lastComment;
+            for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) {
+                var comment = leadingComments_1[_i];
+                if (lastComment) {
+                    var lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end);
+                    var commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos);
+                    if (commentLine >= lastCommentLine + 2) {
+                        break;
+                    }
+                }
+                detachedComments.push(comment);
+                lastComment = comment;
+            }
+            if (detachedComments.length) {
+                var lastCommentLine = getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
+                var nodeLine = getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
+                if (nodeLine >= lastCommentLine + 2) {
+                    emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
+                    emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment);
+                    currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
+                }
+            }
+        }
+        return currentDetachedCommentInfo;
+        function isPinnedComment(comment) {
+            return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 &&
+                currentSourceFile.text.charCodeAt(comment.pos + 2) === 33;
+        }
+    }
+    ts.emitDetachedComments = emitDetachedComments;
     function writeCommentRange(currentSourceFile, writer, comment, newLine) {
         if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42) {
             var firstCommentLineAndCharacter = ts.getLineAndCharacterOfPosition(currentSourceFile, comment.pos);
@@ -5227,16 +5336,16 @@ var ts;
     ts.writeCommentRange = writeCommentRange;
     function modifierToFlag(token) {
         switch (token) {
-            case 113: return 128;
-            case 112: return 16;
-            case 111: return 64;
-            case 110: return 32;
-            case 115: return 256;
-            case 82: return 1;
-            case 122: return 2;
-            case 74: return 32768;
-            case 77: return 1024;
-            case 118: return 512;
+            case 113: return 64;
+            case 112: return 8;
+            case 111: return 32;
+            case 110: return 16;
+            case 115: return 128;
+            case 82: return 2;
+            case 122: return 4;
+            case 74: return 16384;
+            case 77: return 512;
+            case 118: return 256;
         }
         return 0;
     }
@@ -5315,7 +5424,7 @@ var ts;
     }
     ts.isEmptyObjectLiteralOrArrayLiteral = isEmptyObjectLiteralOrArrayLiteral;
     function getLocalSymbolForExportDefault(symbol) {
-        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 1024) ? symbol.valueDeclaration.localSymbol : undefined;
+        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 512) ? symbol.valueDeclaration.localSymbol : undefined;
     }
     ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault;
     function isJavaScript(fileName) {
@@ -5379,6 +5488,12 @@ var ts;
         return result;
     }
     ts.convertToBase64 = convertToBase64;
+    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+        return !ts.isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : ts.getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
+    }
+    ts.convertToRelativePath = convertToRelativePath;
     var carriageReturnLineFeed = "\r\n";
     var lineFeed = "\n";
     function getNewLineCharacter(options) {
@@ -5551,8 +5666,8 @@ var ts;
     }
     function visitEachNode(cbNode, nodes) {
         if (nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
                 var result = cbNode(node);
                 if (result) {
                     return result;
@@ -6013,8 +6128,8 @@ var ts;
         function addJSDocComment(node) {
             var comments = ts.getLeadingCommentRangesOfNode(node, sourceFile);
             if (comments) {
-                for (var _i = 0; _i < comments.length; _i++) {
-                    var comment = comments[_i];
+                for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+                    var comment = comments_1[_i];
                     var jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
                     if (jsDocComment) {
                         node.jsDocComment = jsDocComment;
@@ -6045,7 +6160,7 @@ var ts;
             sourceFile.bindDiagnostics = [];
             sourceFile.languageVersion = languageVersion;
             sourceFile.fileName = ts.normalizePath(fileName);
-            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 8192 : 0;
+            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 4096 : 0;
             sourceFile.languageVariant = ts.isTsx(sourceFile.fileName) ? 1 : 0;
             return sourceFile;
         }
@@ -6881,7 +6996,7 @@ var ts;
             if (node.kind === 8
                 && sourceText.charCodeAt(tokenPos) === 48
                 && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
-                node.flags |= 65536;
+                node.flags |= 32768;
             }
             return node;
         }
@@ -7450,7 +7565,7 @@ var ts;
             if (!arrowFunction) {
                 return undefined;
             }
-            var isAsync = !!(arrowFunction.flags & 512);
+            var isAsync = !!(arrowFunction.flags & 256);
             var lastToken = token;
             arrowFunction.equalsGreaterThanToken = parseExpectedToken(34, false, ts.Diagnostics._0_expected, "=>");
             arrowFunction.body = (lastToken === 34 || lastToken === 15)
@@ -7542,7 +7657,7 @@ var ts;
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) {
             var node = createNode(174);
             setModifiers(node, parseModifiersForArrowFunction());
-            var isAsync = !!(node.flags & 512);
+            var isAsync = !!(node.flags & 256);
             fillSignature(54, false, isAsync, !allowAmbiguity, node);
             if (!node.parameters) {
                 return undefined;
@@ -8156,7 +8271,7 @@ var ts;
             var node = createNode(164);
             parseExpected(19);
             if (scanner.hasPrecedingLineBreak())
-                node.flags |= 2048;
+                node.flags |= 1024;
             node.elements = parseDelimitedList(15, parseArgumentOrArrayLiteralElement);
             parseExpected(20);
             return finishNode(node);
@@ -8211,7 +8326,7 @@ var ts;
             var node = createNode(165);
             parseExpected(15);
             if (scanner.hasPrecedingLineBreak()) {
-                node.flags |= 2048;
+                node.flags |= 1024;
             }
             node.properties = parseDelimitedList(12, parseObjectLiteralElement, true);
             parseExpected(16);
@@ -8227,7 +8342,7 @@ var ts;
             parseExpected(87);
             node.asteriskToken = parseOptionalToken(37);
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512);
+            var isAsync = !!(node.flags & 256);
             node.name =
                 isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
                     isGenerator ? doInYieldContext(parseOptionalIdentifier) :
@@ -8765,10 +8880,10 @@ var ts;
                 case 102:
                     break;
                 case 108:
-                    node.flags |= 16384;
+                    node.flags |= 8192;
                     break;
                 case 74:
-                    node.flags |= 32768;
+                    node.flags |= 16384;
                     break;
                 default:
                     ts.Debug.fail();
@@ -8802,9 +8917,9 @@ var ts;
             setModifiers(node, modifiers);
             parseExpected(87);
             node.asteriskToken = parseOptionalToken(37);
-            node.name = node.flags & 1024 ? parseOptionalIdentifier() : parseIdentifier();
+            node.name = node.flags & 512 ? parseOptionalIdentifier() : parseIdentifier();
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512);
+            var isAsync = !!(node.flags & 256);
             fillSignature(54, isGenerator, isAsync, false, node);
             node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
             return finishNode(node);
@@ -8826,7 +8941,7 @@ var ts;
             method.name = name;
             method.questionToken = questionToken;
             var isGenerator = !!asteriskToken;
-            var isAsync = !!(method.flags & 512);
+            var isAsync = !!(method.flags & 256);
             fillSignature(54, isGenerator, isAsync, false, method);
             method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
             return finishNode(method);
@@ -8838,7 +8953,7 @@ var ts;
             property.name = name;
             property.questionToken = questionToken;
             property.type = parseTypeAnnotation();
-            property.initializer = modifiers && modifiers.flags & 128
+            property.initializer = modifiers && modifiers.flags & 64
                 ? allowInAnd(parseNonParameterInitializer)
                 : doOutsideOfContext(2 | 1, parseNonParameterInitializer);
             parseSemicolon();
@@ -9128,13 +9243,13 @@ var ts;
         }
         function parseModuleOrNamespaceDeclaration(fullStart, decorators, modifiers, flags) {
             var node = createNode(218, fullStart);
-            var namespaceFlag = flags & 131072;
+            var namespaceFlag = flags & 65536;
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.flags |= flags;
             node.name = parseIdentifier();
             node.body = parseOptional(21)
-                ? parseModuleOrNamespaceDeclaration(getNodePos(), undefined, undefined, 1 | namespaceFlag)
+                ? parseModuleOrNamespaceDeclaration(getNodePos(), undefined, undefined, 2 | namespaceFlag)
                 : parseModuleBlock();
             return finishNode(node);
         }
@@ -9149,7 +9264,7 @@ var ts;
         function parseModuleDeclaration(fullStart, decorators, modifiers) {
             var flags = modifiers ? modifiers.flags : 0;
             if (parseOptional(126)) {
-                flags |= 131072;
+                flags |= 65536;
             }
             else {
                 parseExpected(125);
@@ -9363,7 +9478,7 @@ var ts;
         }
         function setExternalModuleIndicator(sourceFile) {
             sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) {
-                return node.flags & 1
+                return node.flags & 2
                     || node.kind === 221 && node.moduleReference.kind === 232
                     || node.kind === 222
                     || node.kind === 227
@@ -9937,8 +10052,8 @@ var ts;
                 array._children = undefined;
                 array.pos += delta;
                 array.end += delta;
-                for (var _i = 0; _i < array.length; _i++) {
-                    var node = array[_i];
+                for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
+                    var node = array_7[_i];
                     visitNode(node);
                 }
             }
@@ -10010,8 +10125,8 @@ var ts;
                     array.intersectsChange = true;
                     array._children = undefined;
                     adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
-                    for (var _i = 0; _i < array.length; _i++) {
-                        var node = array[_i];
+                    for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
+                        var node = array_8[_i];
                         visitNode(node);
                     }
                     return;
@@ -10164,6 +10279,13 @@ var ts;
 var ts;
 (function (ts) {
     ts.bindTime = 0;
+    function or(state1, state2) {
+        return (state1 | state2) & 2
+            ? 2
+            : (state1 & state2) & 8
+                ? 8
+                : 4;
+    }
     function getModuleInstanceState(node) {
         if (node.kind === 215 || node.kind === 216) {
             return 0;
@@ -10171,7 +10293,7 @@ var ts;
         else if (ts.isConstEnumDeclaration(node)) {
             return 2;
         }
-        else if ((node.kind === 222 || node.kind === 221) && !(node.flags & 1)) {
+        else if ((node.kind === 222 || node.kind === 221) && !(node.flags & 2)) {
             return 0;
         }
         else if (node.kind === 219) {
@@ -10198,28 +10320,52 @@ var ts;
         }
     }
     ts.getModuleInstanceState = getModuleInstanceState;
-    function bindSourceFile(file) {
+    var binder = createBinder();
+    function bindSourceFile(file, options) {
         var start = new Date().getTime();
-        bindSourceFileWorker(file);
+        binder(file, options);
         ts.bindTime += new Date().getTime() - start;
     }
     ts.bindSourceFile = bindSourceFile;
-    function bindSourceFileWorker(file) {
+    function createBinder() {
+        var file;
+        var options;
         var parent;
         var container;
         var blockScopeContainer;
         var lastContainer;
         var seenThisKeyword;
-        var inStrictMode = !!file.externalModuleIndicator;
+        var hasExplicitReturn;
+        var currentReachabilityState;
+        var labelStack;
+        var labelIndexMap;
+        var implicitLabels;
+        var inStrictMode;
         var symbolCount = 0;
-        var Symbol = ts.objectAllocator.getSymbolConstructor();
-        var classifiableNames = {};
-        if (!file.locals) {
-            bind(file);
-            file.symbolCount = symbolCount;
-            file.classifiableNames = classifiableNames;
+        var Symbol;
+        var classifiableNames;
+        function bindSourceFile(f, opts) {
+            file = f;
+            options = opts;
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            Symbol = ts.objectAllocator.getSymbolConstructor();
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            hasExplicitReturn = false;
+            labelStack = undefined;
+            labelIndexMap = undefined;
+            implicitLabels = undefined;
         }
-        return;
+        return bindSourceFile;
         function createSymbol(flags, name) {
             symbolCount++;
             return new Symbol(flags, name);
@@ -10270,7 +10416,7 @@ var ts;
                     return node.isExportEquals ? "export=" : "default";
                 case 213:
                 case 214:
-                    return node.flags & 1024 ? "default" : undefined;
+                    return node.flags & 512 ? "default" : undefined;
             }
         }
         function getDisplayName(node) {
@@ -10278,7 +10424,7 @@ var ts;
         }
         function declareSymbol(symbolTable, parent, node, includes, excludes) {
             ts.Debug.assert(!ts.hasDynamicName(node));
-            var isDefaultExport = node.flags & 1024;
+            var isDefaultExport = node.flags & 512;
             var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
             var symbol;
             if (name !== undefined) {
@@ -10296,7 +10442,7 @@ var ts;
                         ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : ts.Diagnostics.Duplicate_identifier_0;
                     ts.forEach(symbol.declarations, function (declaration) {
-                        if (declaration.flags & 1024) {
+                        if (declaration.flags & 512) {
                             message = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
                         }
                     });
@@ -10315,7 +10461,7 @@ var ts;
             return symbol;
         }
         function declareModuleMember(node, symbolFlags, symbolExcludes) {
-            var hasExportModifier = ts.getCombinedNodeFlags(node) & 1;
+            var hasExportModifier = ts.getCombinedNodeFlags(node) & 2;
             if (symbolFlags & 8388608) {
                 if (node.kind === 230 || (node.kind === 221 && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -10325,7 +10471,7 @@ var ts;
                 }
             }
             else {
-                if (hasExportModifier || container.flags & 262144) {
+                if (hasExportModifier || container.flags & 131072) {
                     var exportKind = (symbolFlags & 107455 ? 1048576 : 0) |
                         (symbolFlags & 793056 ? 2097152 : 0) |
                         (symbolFlags & 1536 ? 4194304 : 0);
@@ -10356,18 +10502,202 @@ var ts;
                 blockScopeContainer = node;
                 blockScopeContainer.locals = undefined;
             }
-            if (node.kind === 215) {
+            var savedReachabilityState;
+            var savedLabelStack;
+            var savedLabels;
+            var savedImplicitLabels;
+            var savedHasExplicitReturn;
+            var kind = node.kind;
+            var flags = node.flags;
+            flags &= ~1572864;
+            if (kind === 215) {
                 seenThisKeyword = false;
-                ts.forEachChild(node, bind);
-                node.flags = seenThisKeyword ? node.flags | 524288 : node.flags & ~524288;
             }
-            else {
-                ts.forEachChild(node, bind);
+            var saveState = kind === 248 || kind === 219 || ts.isFunctionLikeKind(kind);
+            if (saveState) {
+                savedReachabilityState = currentReachabilityState;
+                savedLabelStack = labelStack;
+                savedLabels = labelIndexMap;
+                savedImplicitLabels = implicitLabels;
+                savedHasExplicitReturn = hasExplicitReturn;
+                currentReachabilityState = 2;
+                hasExplicitReturn = false;
+                labelStack = labelIndexMap = implicitLabels = undefined;
+            }
+            bindReachableStatement(node);
+            if (currentReachabilityState === 2 && ts.isFunctionLikeKind(kind) && ts.nodeIsPresent(node.body)) {
+                flags |= 524288;
+                if (hasExplicitReturn) {
+                    flags |= 1048576;
+                }
+            }
+            if (kind === 215) {
+                flags = seenThisKeyword ? flags | 262144 : flags & ~262144;
+            }
+            node.flags = flags;
+            if (saveState) {
+                hasExplicitReturn = savedHasExplicitReturn;
+                currentReachabilityState = savedReachabilityState;
+                labelStack = savedLabelStack;
+                labelIndexMap = savedLabels;
+                implicitLabels = savedImplicitLabels;
             }
             container = saveContainer;
             parent = saveParent;
             blockScopeContainer = savedBlockScopeContainer;
         }
+        function bindReachableStatement(node) {
+            if (checkUnreachable(node)) {
+                ts.forEachChild(node, bind);
+                return;
+            }
+            switch (node.kind) {
+                case 198:
+                    bindWhileStatement(node);
+                    break;
+                case 197:
+                    bindDoStatement(node);
+                    break;
+                case 199:
+                    bindForStatement(node);
+                    break;
+                case 200:
+                case 201:
+                    bindForInOrForOfStatement(node);
+                    break;
+                case 196:
+                    bindIfStatement(node);
+                    break;
+                case 204:
+                case 208:
+                    bindReturnOrThrow(node);
+                    break;
+                case 203:
+                case 202:
+                    bindBreakOrContinueStatement(node);
+                    break;
+                case 209:
+                    bindTryStatement(node);
+                    break;
+                case 206:
+                    bindSwitchStatement(node);
+                    break;
+                case 220:
+                    bindCaseBlock(node);
+                    break;
+                case 207:
+                    bindLabeledStatement(node);
+                    break;
+                default:
+                    ts.forEachChild(node, bind);
+                    break;
+            }
+        }
+        function bindWhileStatement(n) {
+            var preWhileState = n.expression.kind === 84 ? 4 : currentReachabilityState;
+            var postWhileState = n.expression.kind === 99 ? 4 : currentReachabilityState;
+            bind(n.expression);
+            currentReachabilityState = preWhileState;
+            var postWhileLabel = pushImplicitLabel();
+            bind(n.statement);
+            popImplicitLabel(postWhileLabel, postWhileState);
+        }
+        function bindDoStatement(n) {
+            var preDoState = currentReachabilityState;
+            var postDoLabel = pushImplicitLabel();
+            bind(n.statement);
+            var postDoState = n.expression.kind === 99 ? 4 : preDoState;
+            popImplicitLabel(postDoLabel, postDoState);
+            bind(n.expression);
+        }
+        function bindForStatement(n) {
+            var preForState = currentReachabilityState;
+            var postForLabel = pushImplicitLabel();
+            bind(n.initializer);
+            bind(n.condition);
+            bind(n.incrementor);
+            bind(n.statement);
+            var isInfiniteLoop = (!n.condition || n.condition.kind === 99);
+            var postForState = isInfiniteLoop ? 4 : preForState;
+            popImplicitLabel(postForLabel, postForState);
+        }
+        function bindForInOrForOfStatement(n) {
+            var preStatementState = currentReachabilityState;
+            var postStatementLabel = pushImplicitLabel();
+            bind(n.initializer);
+            bind(n.expression);
+            bind(n.statement);
+            popImplicitLabel(postStatementLabel, preStatementState);
+        }
+        function bindIfStatement(n) {
+            var ifTrueState = n.expression.kind === 84 ? 4 : currentReachabilityState;
+            var ifFalseState = n.expression.kind === 99 ? 4 : currentReachabilityState;
+            currentReachabilityState = ifTrueState;
+            bind(n.expression);
+            bind(n.thenStatement);
+            if (n.elseStatement) {
+                var preElseState = currentReachabilityState;
+                currentReachabilityState = ifFalseState;
+                bind(n.elseStatement);
+                currentReachabilityState = or(currentReachabilityState, preElseState);
+            }
+            else {
+                currentReachabilityState = or(currentReachabilityState, ifFalseState);
+            }
+        }
+        function bindReturnOrThrow(n) {
+            bind(n.expression);
+            if (n.kind === 204) {
+                hasExplicitReturn = true;
+            }
+            currentReachabilityState = 4;
+        }
+        function bindBreakOrContinueStatement(n) {
+            bind(n.label);
+            var isValidJump = jumpToLabel(n.label, n.kind === 203 ? currentReachabilityState : 4);
+            if (isValidJump) {
+                currentReachabilityState = 4;
+            }
+        }
+        function bindTryStatement(n) {
+            var preTryState = currentReachabilityState;
+            bind(n.tryBlock);
+            var postTryState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.catchClause);
+            var postCatchState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.finallyBlock);
+            currentReachabilityState = or(postTryState, postCatchState);
+        }
+        function bindSwitchStatement(n) {
+            var preSwitchState = currentReachabilityState;
+            var postSwitchLabel = pushImplicitLabel();
+            bind(n.expression);
+            bind(n.caseBlock);
+            var hasDefault = ts.forEach(n.caseBlock.clauses, function (c) { return c.kind === 242; });
+            var postSwitchState = hasDefault && currentReachabilityState !== 2 ? 4 : preSwitchState;
+            popImplicitLabel(postSwitchLabel, postSwitchState);
+        }
+        function bindCaseBlock(n) {
+            var startState = currentReachabilityState;
+            for (var _i = 0, _a = n.clauses; _i < _a.length; _i++) {
+                var clause = _a[_i];
+                currentReachabilityState = startState;
+                bind(clause);
+                if (clause.statements.length && currentReachabilityState === 2 && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, ts.Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+        function bindLabeledStatement(n) {
+            bind(n.label);
+            var ok = pushNamedLabel(n.label);
+            bind(n.statement);
+            if (ok) {
+                popNamedLabel(n.label, currentReachabilityState);
+            }
+        }
         function getContainerFlags(node) {
             switch (node.kind) {
                 case 186:
@@ -10447,7 +10777,7 @@ var ts;
             }
         }
         function declareClassMember(node, symbolFlags, symbolExcludes) {
-            return node.flags & 128
+            return node.flags & 64
                 ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
                 : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
         }
@@ -10456,15 +10786,6 @@ var ts;
                 ? declareModuleMember(node, symbolFlags, symbolExcludes)
                 : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
         }
-        function isAmbientContext(node) {
-            while (node) {
-                if (node.flags & 2) {
-                    return true;
-                }
-                node = node.parent;
-            }
-            return false;
-        }
         function hasExportDeclarations(node) {
             var body = node.kind === 248 ? node : node.body;
             if (body.kind === 248 || body.kind === 219) {
@@ -10478,11 +10799,11 @@ var ts;
             return false;
         }
         function setExportContextFlag(node) {
-            if (isAmbientContext(node) && !hasExportDeclarations(node)) {
-                node.flags |= 262144;
+            if (ts.isInAmbientContext(node) && !hasExportDeclarations(node)) {
+                node.flags |= 131072;
             }
             else {
-                node.flags &= ~262144;
+                node.flags &= ~131072;
             }
         }
         function bindModuleDeclaration(node) {
@@ -10633,7 +10954,7 @@ var ts;
             }
         }
         function checkStrictModeNumericLiteral(node) {
-            if (inStrictMode && node.flags & 65536) {
+            if (inStrictMode && node.flags & 32768) {
                 file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
         }
@@ -10651,10 +10972,10 @@ var ts;
         }
         function checkStrictModeWithStatement(node) {
             if (inStrictMode) {
-                grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
             }
         }
-        function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+        function errorOnFirstToken(node, message, arg0, arg1, arg2) {
             var span = ts.getSpanOfTokenAtPosition(file, node.pos);
             file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
         }
@@ -10662,6 +10983,9 @@ var ts;
             return "__" + ts.indexOf(node.parent.parameters, node);
         }
         function bind(node) {
+            if (!node) {
+                return;
+            }
             node.parent = parent;
             var savedInStrictMode = inStrictMode;
             if (!savedInStrictMode) {
@@ -10689,8 +11013,8 @@ var ts;
             }
         }
         function updateStrictModeStatementList(statements) {
-            for (var _i = 0; _i < statements.length; _i++) {
-                var statement = statements[_i];
+            for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+                var statement = statements_1[_i];
                 if (!ts.isPrologueDirective(statement)) {
                     return;
                 }
@@ -10877,7 +11201,7 @@ var ts;
             else {
                 declareSymbolAndAddToSymbolTable(node, 1, 107455);
             }
-            if (node.flags & 112 &&
+            if (node.flags & 56 &&
                 node.parent.kind === 144 &&
                 ts.isClassLike(node.parent.parent)) {
                 var classDeclaration = node.parent.parent;
@@ -10889,6 +11213,95 @@ var ts;
                 ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
+        function pushNamedLabel(name) {
+            initializeReachabilityStateIfNecessary();
+            if (ts.hasProperty(labelIndexMap, name.text)) {
+                return false;
+            }
+            labelIndexMap[name.text] = labelStack.push(1) - 1;
+            return true;
+        }
+        function pushImplicitLabel() {
+            initializeReachabilityStateIfNecessary();
+            var index = labelStack.push(1) - 1;
+            implicitLabels.push(index);
+            return index;
+        }
+        function popNamedLabel(label, outerState) {
+            var index = labelIndexMap[label.text];
+            ts.Debug.assert(index !== undefined);
+            ts.Debug.assert(labelStack.length == index + 1);
+            labelIndexMap[label.text] = undefined;
+            setCurrentStateAtLabel(labelStack.pop(), outerState, label);
+        }
+        function popImplicitLabel(implicitLabelIndex, outerState) {
+            if (labelStack.length !== implicitLabelIndex + 1) {
+                ts.Debug.assert(false, "Label stack: " + labelStack.length + ", index:" + implicitLabelIndex);
+            }
+            var i = implicitLabels.pop();
+            if (implicitLabelIndex !== i) {
+                ts.Debug.assert(false, "i: " + i + ", index: " + implicitLabelIndex);
+            }
+            setCurrentStateAtLabel(labelStack.pop(), outerState, undefined);
+        }
+        function setCurrentStateAtLabel(innerMergedState, outerState, label) {
+            if (innerMergedState === 1) {
+                if (label && !options.allowUnusedLabels) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(label, ts.Diagnostics.Unused_label));
+                }
+                currentReachabilityState = outerState;
+            }
+            else {
+                currentReachabilityState = or(innerMergedState, outerState);
+            }
+        }
+        function jumpToLabel(label, outerState) {
+            initializeReachabilityStateIfNecessary();
+            var index = label ? labelIndexMap[label.text] : ts.lastOrUndefined(implicitLabels);
+            if (index === undefined) {
+                return false;
+            }
+            var stateAtLabel = labelStack[index];
+            labelStack[index] = stateAtLabel === 1 ? outerState : or(stateAtLabel, outerState);
+            return true;
+        }
+        function checkUnreachable(node) {
+            switch (currentReachabilityState) {
+                case 4:
+                    var reportError = ts.isStatement(node) ||
+                        node.kind === 214 ||
+                        (node.kind === 218 && shouldReportErrorOnModuleDeclaration(node)) ||
+                        (node.kind === 217 && (!ts.isConstEnumDeclaration(node) || options.preserveConstEnums));
+                    if (reportError) {
+                        currentReachabilityState = 8;
+                        var reportUnreachableCode = !options.allowUnreachableCode &&
+                            !ts.isInAmbientContext(node) &&
+                            (node.kind !== 193 ||
+                                ts.getCombinedNodeFlags(node.declarationList) & 24576 ||
+                                ts.forEach(node.declarationList.declarations, function (d) { return d.initializer; }));
+                        if (reportUnreachableCode) {
+                            errorOnFirstToken(node, ts.Diagnostics.Unreachable_code_detected);
+                        }
+                    }
+                case 8:
+                    return true;
+                default:
+                    return false;
+            }
+            function shouldReportErrorOnModuleDeclaration(node) {
+                var instanceState = getModuleInstanceState(node);
+                return instanceState === 1 || (instanceState === 2 && options.preserveConstEnums);
+            }
+        }
+        function initializeReachabilityStateIfNecessary() {
+            if (labelIndexMap) {
+                return;
+            }
+            currentReachabilityState = 2;
+            labelIndexMap = {};
+            labelStack = [];
+            implicitLabels = [];
+        }
     }
 })(ts || (ts = {}));
 var ts;
@@ -11014,6 +11427,7 @@ var ts;
         var getInstantiatedGlobalPromiseLikeType;
         var getGlobalPromiseConstructorLikeType;
         var getGlobalThenableType;
+        var jsxElementClassType;
         var tupleTypes = {};
         var unionTypes = {};
         var intersectionTypes = {};
@@ -11262,7 +11676,7 @@ var ts;
                     }
                     var initializerOfNonStaticProperty = current.parent &&
                         current.parent.kind === 141 &&
-                        (current.parent.flags & 128) === 0 &&
+                        (current.parent.flags & 64) === 0 &&
                         current.parent.initializer === current;
                     if (initializerOfNonStaticProperty) {
                         return true;
@@ -11321,7 +11735,7 @@ var ts;
                         break;
                     case 141:
                     case 140:
-                        if (ts.isClassLike(location.parent) && !(location.flags & 128)) {
+                        if (ts.isClassLike(location.parent) && !(location.flags & 64)) {
                             var ctor = findConstructorDeclaration(location.parent);
                             if (ctor && ctor.locals) {
                                 if (getSymbol(ctor.locals, name, meaning & 107455)) {
@@ -11334,7 +11748,7 @@ var ts;
                     case 186:
                     case 215:
                         if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056)) {
-                            if (lastLocation && lastLocation.flags & 128) {
+                            if (lastLocation && lastLocation.flags & 64) {
                                 error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters);
                                 return undefined;
                             }
@@ -11768,8 +12182,8 @@ var ts;
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
-            for (var _i = 0; _i < members.length; _i++) {
-                var member = members[_i];
+            for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+                var member = members_1[_i];
                 if (member.kind === 144 && ts.nodeIsPresent(member.body)) {
                     return member;
                 }
@@ -11975,7 +12389,7 @@ var ts;
                 if (!isDeclarationVisible(declaration)) {
                     var anyImportSyntax = getAnyImportSyntax(declaration);
                     if (anyImportSyntax &&
-                        !(anyImportSyntax.flags & 1) &&
+                        !(anyImportSyntax.flags & 2) &&
                         isDeclarationVisible(anyImportSyntax.parent)) {
                         getNodeLinks(declaration).isVisible = true;
                         if (aliasesToMakeVisible) {
@@ -12105,8 +12519,8 @@ var ts;
                             walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning));
                         }
                         if (accessibleSymbolChain) {
-                            for (var _i = 0; _i < accessibleSymbolChain.length; _i++) {
-                                var accessibleSymbol = accessibleSymbolChain[_i];
+                            for (var _i = 0, accessibleSymbolChain_1 = accessibleSymbolChain; _i < accessibleSymbolChain_1.length; _i++) {
+                                var accessibleSymbol = accessibleSymbolChain_1[_i];
                                 appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
                             }
                         }
@@ -12272,7 +12686,7 @@ var ts;
                     }
                     function shouldWriteTypeOfFunctionSymbol() {
                         var isStaticMethodSymbol = !!(symbol.flags & 8192 &&
-                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 128; }));
+                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 64; }));
                         var isNonLocalFunctionSymbol = !!(symbol.flags & 16) &&
                             (symbol.parent ||
                                 ts.forEach(symbol.declarations, function (declaration) {
@@ -12378,8 +12792,8 @@ var ts;
                         var t = getTypeOfSymbol(p);
                         if (p.flags & (16 | 8192) && !getPropertiesOfObjectType(t).length) {
                             var signatures = getSignaturesOfType(t, 0);
-                            for (var _f = 0; _f < signatures.length; _f++) {
-                                var signature = signatures[_f];
+                            for (var _f = 0, signatures_1 = signatures; _f < signatures_1.length; _f++) {
+                                var signature = signatures_1[_f];
                                 buildSymbolDisplay(p, writer);
                                 if (p.flags & 536870912) {
                                     writePunctuation(writer, 53);
@@ -12582,7 +12996,7 @@ var ts;
                     case 217:
                     case 221:
                         var parent_4 = getDeclarationContainer(node);
-                        if (!(ts.getCombinedNodeFlags(node) & 1) &&
+                        if (!(ts.getCombinedNodeFlags(node) & 2) &&
                             !(node.kind !== 221 && parent_4.kind !== 248 && ts.isInAmbientContext(parent_4))) {
                             return isGlobalSourceFile(parent_4);
                         }
@@ -12593,7 +13007,7 @@ var ts;
                     case 146:
                     case 143:
                     case 142:
-                        if (node.flags & (32 | 64)) {
+                        if (node.flags & (16 | 32)) {
                             return false;
                         }
                     case 144:
@@ -13022,8 +13436,8 @@ var ts;
             }
         }
         function appendTypeParameters(typeParameters, declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
+                var declaration = declarations_2[_i];
                 var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
                 if (!typeParameters) {
                     typeParameters = [tp];
@@ -13204,13 +13618,13 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var declaration = _a[_i];
                 if (declaration.kind === 215) {
-                    if (declaration.flags & 524288) {
+                    if (declaration.flags & 262144) {
                         return false;
                     }
                     var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
                     if (baseTypeNodes) {
-                        for (var _b = 0; _b < baseTypeNodes.length; _b++) {
-                            var node = baseTypeNodes[_b];
+                        for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
+                            var node = baseTypeNodes_1[_b];
                             if (ts.isSupportedExpressionWithTypeArguments(node)) {
                                 var baseSymbol = resolveEntityName(node.expression, 793056, true);
                                 if (!baseSymbol || !(baseSymbol.flags & 64) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
@@ -13378,23 +13792,23 @@ var ts;
         }
         function createSymbolTable(symbols) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                var symbol = symbols_1[_i];
                 result[symbol.name] = symbol;
             }
             return result;
         }
         function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+                var symbol = symbols_2[_i];
                 result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
             }
             return result;
         }
         function addInheritedMembers(symbols, baseSymbols) {
-            for (var _i = 0; _i < baseSymbols.length; _i++) {
-                var s = baseSymbols[_i];
+            for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
+                var s = baseSymbols_1[_i];
                 if (!ts.hasProperty(symbols, s.name)) {
                     symbols[s.name] = s;
                 }
@@ -13402,8 +13816,8 @@ var ts;
         }
         function addInheritedSignatures(signatures, baseSignatures) {
             if (baseSignatures) {
-                for (var _i = 0; _i < baseSignatures.length; _i++) {
-                    var signature = baseSignatures[_i];
+                for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
+                    var signature = baseSignatures_1[_i];
                     signatures.push(signature);
                 }
             }
@@ -13446,8 +13860,8 @@ var ts;
                     members = createSymbolTable(source.declaredProperties);
                 }
                 var thisArgument = ts.lastOrUndefined(typeArguments);
-                for (var _i = 0; _i < baseTypes.length; _i++) {
-                    var baseType = baseTypes[_i];
+                for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
+                    var baseType = baseTypes_1[_i];
                     var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
                     addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
                     callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0));
@@ -13493,8 +13907,8 @@ var ts;
             var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode);
             var typeArgCount = typeArguments ? typeArguments.length : 0;
             var result = [];
-            for (var _i = 0; _i < baseSignatures.length; _i++) {
-                var baseSig = baseSignatures[_i];
+            for (var _i = 0, baseSignatures_2 = baseSignatures; _i < baseSignatures_2.length; _i++) {
+                var baseSig = baseSignatures_2[_i];
                 var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
                 if (typeParamCount === typeArgCount) {
                     var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
@@ -13522,8 +13936,8 @@ var ts;
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
         }
         function findMatchingSignature(signatureList, signature, partialMatch, ignoreReturnTypes) {
-            for (var _i = 0; _i < signatureList.length; _i++) {
-                var s = signatureList[_i];
+            for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
+                var s = signatureList_1[_i];
                 if (compareSignatures(s, signature, partialMatch, ignoreReturnTypes, compareTypes)) {
                     return s;
                 }
@@ -13577,8 +13991,8 @@ var ts;
         }
         function getUnionIndexType(types, kind) {
             var indexTypes = [];
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+                var type = types_1[_i];
                 var indexType = getIndexTypeOfType(type, kind);
                 if (!indexType) {
                     return undefined;
@@ -13742,12 +14156,12 @@ var ts;
         function createUnionOrIntersectionProperty(containingType, name) {
             var types = containingType.types;
             var props;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
+                var current = types_2[_i];
                 var type = getApparentType(current);
                 if (type !== unknownType) {
                     var prop = getPropertyOfType(type, name);
-                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (32 | 64))) {
+                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (16 | 32))) {
                         if (!props) {
                             props = [prop];
                         }
@@ -13768,8 +14182,8 @@ var ts;
             }
             var propTypes = [];
             var declarations = [];
-            for (var _a = 0; _a < props.length; _a++) {
-                var prop = props[_a];
+            for (var _a = 0, props_1 = props; _a < props_1.length; _a++) {
+                var prop = props_1[_a];
                 if (prop.declarations) {
                     ts.addRange(declarations, prop.declarations);
                 }
@@ -14102,8 +14516,8 @@ var ts;
         }
         function getPropagatingFlagsOfTypes(types) {
             var result = 0;
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
+                var type = types_3[_i];
                 result |= type.flags;
             }
             return result & 14680064;
@@ -14224,8 +14638,8 @@ var ts;
         function getTypeOfGlobalSymbol(symbol, arity) {
             function getTypeDeclaration(symbol) {
                 var declarations = symbol.declarations;
-                for (var _i = 0; _i < declarations.length; _i++) {
-                    var declaration = declarations[_i];
+                for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
+                    var declaration = declarations_3[_i];
                     switch (declaration.kind) {
                         case 214:
                         case 215:
@@ -14323,8 +14737,8 @@ var ts;
             }
         }
         function addTypesToSet(typeSet, types, typeSetKind) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
+                var type = types_4[_i];
                 addTypeToSet(typeSet, type, typeSetKind);
             }
         }
@@ -14346,8 +14760,8 @@ var ts;
             }
         }
         function containsTypeAny(types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
+                var type = types_5[_i];
                 if (isTypeAny(type)) {
                     return true;
                 }
@@ -14450,7 +14864,8 @@ var ts;
             var container = ts.getThisContainer(node, false);
             var parent = container && container.parent;
             if (parent && (ts.isClassLike(parent) || parent.kind === 215)) {
-                if (!(container.flags & 128)) {
+                if (!(container.flags & 64) &&
+                    (container.kind !== 144 || ts.isNodeDescendentOf(node, container.body))) {
                     return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
                 }
             }
@@ -14515,8 +14930,8 @@ var ts;
         function instantiateList(items, mapper, instantiator) {
             if (items && items.length) {
                 var result = [];
-                for (var _i = 0; _i < items.length; _i++) {
-                    var v = items[_i];
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var v = items_1[_i];
                     result.push(instantiator(v, mapper));
                 }
                 return result;
@@ -14555,8 +14970,8 @@ var ts;
                 case 2: return createBinaryTypeEraser(sources[0], sources[1]);
             }
             return function (t) {
-                for (var _i = 0; _i < sources.length; _i++) {
-                    var source = sources[_i];
+                for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
+                    var source = sources_1[_i];
                     if (t === source) {
                         return anyType;
                     }
@@ -14921,8 +15336,8 @@ var ts;
             function eachTypeRelatedToSomeType(source, target) {
                 var result = -1;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
+                    var sourceType = sourceTypes_1[_i];
                     var related = typeRelatedToSomeType(sourceType, target, false);
                     if (!related) {
                         return 0;
@@ -14944,8 +15359,8 @@ var ts;
             function typeRelatedToEachType(source, target, reportErrors) {
                 var result = -1;
                 var targetTypes = target.types;
-                for (var _i = 0; _i < targetTypes.length; _i++) {
-                    var targetType = targetTypes[_i];
+                for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
+                    var targetType = targetTypes_1[_i];
                     var related = isRelatedTo(source, targetType, reportErrors);
                     if (!related) {
                         return 0;
@@ -14967,8 +15382,8 @@ var ts;
             function eachTypeRelatedToType(source, target, reportErrors) {
                 var result = -1;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_2 = sourceTypes; _i < sourceTypes_2.length; _i++) {
+                    var sourceType = sourceTypes_2[_i];
                     var related = isRelatedTo(sourceType, target, reportErrors);
                     if (!related) {
                         return 0;
@@ -15081,8 +15496,8 @@ var ts;
                 var result = -1;
                 var properties = getPropertiesOfObjectType(target);
                 var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 524288);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {
+                    var targetProp = properties_1[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
@@ -15096,20 +15511,20 @@ var ts;
                         else if (!(targetProp.flags & 134217728)) {
                             var sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
                             var targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
-                            if (sourcePropFlags & 32 || targetPropFlags & 32) {
+                            if (sourcePropFlags & 16 || targetPropFlags & 16) {
                                 if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
                                     if (reportErrors) {
-                                        if (sourcePropFlags & 32 && targetPropFlags & 32) {
+                                        if (sourcePropFlags & 16 && targetPropFlags & 16) {
                                             reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
                                         }
                                         else {
-                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 32 ? source : target), typeToString(sourcePropFlags & 32 ? target : source));
+                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 16 ? source : target), typeToString(sourcePropFlags & 16 ? target : source));
                                         }
                                     }
                                     return 0;
                                 }
                             }
-                            else if (targetPropFlags & 64) {
+                            else if (targetPropFlags & 32) {
                                 var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32;
                                 var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
                                 var targetClass = getDeclaredTypeOfSymbol(targetProp.parent);
@@ -15120,7 +15535,7 @@ var ts;
                                     return 0;
                                 }
                             }
-                            else if (sourcePropFlags & 64) {
+                            else if (sourcePropFlags & 32) {
                                 if (reportErrors) {
                                     reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
                                 }
@@ -15155,8 +15570,8 @@ var ts;
                     return 0;
                 }
                 var result = -1;
-                for (var _i = 0; _i < sourceProperties.length; _i++) {
-                    var sourceProp = sourceProperties[_i];
+                for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
+                    var sourceProp = sourceProperties_1[_i];
                     var targetProp = getPropertyOfObjectType(target, sourceProp.name);
                     if (!targetProp) {
                         return 0;
@@ -15188,13 +15603,13 @@ var ts;
                         return result;
                     }
                 }
-                outer: for (var _i = 0; _i < targetSignatures.length; _i++) {
-                    var t = targetSignatures[_i];
+                outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
+                    var t = targetSignatures_1[_i];
                     if (!t.hasStringLiterals || target.flags & 262144) {
                         var localErrors = reportErrors;
                         var checkedAbstractAssignability = false;
-                        for (var _a = 0; _a < sourceSignatures.length; _a++) {
-                            var s = sourceSignatures[_a];
+                        for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) {
+                            var s = sourceSignatures_1[_a];
                             if (!s.hasStringLiterals || source.flags & 262144) {
                                 var related = signatureRelatedTo(s, t, localErrors);
                                 if (related) {
@@ -15222,8 +15637,8 @@ var ts;
                         var targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
                         var sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
                         var targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
-                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 256;
-                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 256;
+                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 128;
+                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 128;
                         if (sourceIsAbstract && !(targetIsAbstract && targetDecl)) {
                             if (reportErrors) {
                                 reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
@@ -15424,8 +15839,8 @@ var ts;
             if (sourceProp === targetProp) {
                 return -1;
             }
-            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 | 64);
-            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 | 64);
+            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (16 | 32);
+            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (16 | 32);
             if (sourcePropAccessibility !== targetPropAccessibility) {
                 return 0;
             }
@@ -15491,8 +15906,8 @@ var ts;
             return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1;
         }
         function isSupertypeOfEach(candidate, types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_6 = types; _i < types_6.length; _i++) {
+                var type = types_6[_i];
                 if (candidate !== type && !isTypeSubtypeOf(type, candidate))
                     return false;
             }
@@ -15705,8 +16120,8 @@ var ts;
         }
         function createInferenceContext(typeParameters, inferUnionTypes) {
             var inferences = [];
-            for (var _i = 0; _i < typeParameters.length; _i++) {
-                var unused = typeParameters[_i];
+            for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
+                var unused = typeParameters_1[_i];
                 inferences.push({
                     primary: undefined, secondary: undefined, isFixed: false
                 });
@@ -15772,8 +16187,8 @@ var ts;
                     var targetTypes = target.types;
                     var typeParameterCount = 0;
                     var typeParameter;
-                    for (var _i = 0; _i < targetTypes.length; _i++) {
-                        var t = targetTypes[_i];
+                    for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
+                        var t = targetTypes_2[_i];
                         if (t.flags & 512 && ts.contains(context.typeParameters, t)) {
                             typeParameter = t;
                             typeParameterCount++;
@@ -15790,8 +16205,8 @@ var ts;
                 }
                 else if (source.flags & 49152) {
                     var sourceTypes = source.types;
-                    for (var _a = 0; _a < sourceTypes.length; _a++) {
-                        var sourceType = sourceTypes[_a];
+                    for (var _a = 0, sourceTypes_3 = sourceTypes; _a < sourceTypes_3.length; _a++) {
+                        var sourceType = sourceTypes_3[_a];
                         inferFromTypes(sourceType, target);
                     }
                 }
@@ -15824,8 +16239,8 @@ var ts;
             }
             function inferFromProperties(source, target) {
                 var properties = getPropertiesOfObjectType(target);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_2 = properties; _i < properties_2.length; _i++) {
+                    var targetProp = properties_2[_i];
                     var sourceProp = getPropertyOfObjectType(source, targetProp.name);
                     if (sourceProp) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
@@ -16316,7 +16731,7 @@ var ts;
                     break;
                 case 141:
                 case 140:
-                    if (container.flags & 128) {
+                    if (container.flags & 64) {
                         error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
                     }
                     break;
@@ -16329,7 +16744,7 @@ var ts;
             }
             if (ts.isClassLike(container.parent)) {
                 var symbol = getSymbolOfNode(container.parent);
-                return container.flags & 128 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
+                return container.flags & 64 ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
             }
             return anyType;
         }
@@ -16357,7 +16772,7 @@ var ts;
             var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             var nodeCheckFlag = 0;
             if (canUseSuperExpression) {
-                if ((container.flags & 128) || isCallExpression) {
+                if ((container.flags & 64) || isCallExpression) {
                     nodeCheckFlag = 512;
                 }
                 else {
@@ -16402,7 +16817,7 @@ var ts;
                 }
                 else {
                     if (container && ts.isClassLike(container.parent)) {
-                        if (container.flags & 128) {
+                        if (container.flags & 64) {
                             return container.kind === 143 ||
                                 container.kind === 142 ||
                                 container.kind === 145 ||
@@ -16541,8 +16956,8 @@ var ts;
             var types = type.types;
             var mappedType;
             var mappedTypes;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
+                var current = types_7[_i];
                 var t = mapper(current);
                 if (t) {
                     if (!mappedType) {
@@ -16706,8 +17121,8 @@ var ts;
             }
             var signatureList;
             var types = type.types;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
+                var current = types_8[_i];
                 var signature = getNonGenericSignature(current);
                 if (signature) {
                     if (!signatureList) {
@@ -16758,8 +17173,8 @@ var ts;
             var hasSpreadElement = false;
             var elementTypes = [];
             var inDestructuringPattern = isAssignmentTarget(node);
-            for (var _i = 0; _i < elements.length; _i++) {
-                var e = elements[_i];
+            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+                var e = elements_1[_i];
                 if (inDestructuringPattern && e.kind === 185) {
                     var restArrayType = checkExpression(e.expression, contextualMapper);
                     var restElementType = getIndexTypeOfType(restArrayType, 1) ||
@@ -17018,8 +17433,8 @@ var ts;
         function checkJsxSpreadAttribute(node, elementAttributesType, nameTable) {
             var type = checkExpression(node.expression);
             var props = getPropertiesOfType(type);
-            for (var _i = 0; _i < props.length; _i++) {
-                var prop = props[_i];
+            for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+                var prop = props_2[_i];
                 if (!nameTable[prop.name]) {
                     var targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
                     if (targetPropSym) {
@@ -17188,7 +17603,6 @@ var ts;
             var prop = getPropertyOfType(attributesType, attrib.name.text);
             return prop || unknownSymbol;
         }
-        var jsxElementClassType = undefined;
         function getJsxGlobalElementClassType() {
             if (!jsxElementClassType) {
                 jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
@@ -17255,7 +17669,7 @@ var ts;
             return s.valueDeclaration ? s.valueDeclaration.kind : 141;
         }
         function getDeclarationFlagsFromSymbol(s) {
-            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 16 | 128 : 0;
+            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 ? 8 | 64 : 0;
         }
         function checkClassPropertyAccess(node, left, type, prop) {
             var flags = getDeclarationFlagsFromSymbol(prop);
@@ -17268,17 +17682,17 @@ var ts;
                     error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
                     return false;
                 }
-                if (flags & 256) {
+                if (flags & 128) {
                     error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(declaringClass));
                     return false;
                 }
             }
-            if (!(flags & (32 | 64))) {
+            if (!(flags & (16 | 32))) {
                 return true;
             }
             var enclosingClassDeclaration = ts.getContainingClass(node);
             var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
-            if (flags & 32) {
+            if (flags & 16) {
                 if (declaringClass !== enclosingClass) {
                     error(node, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass));
                     return false;
@@ -17292,7 +17706,7 @@ var ts;
                 error(node, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(declaringClass));
                 return false;
             }
-            if (flags & 128) {
+            if (flags & 64) {
                 return true;
             }
             if (type.flags & 33554432) {
@@ -17472,8 +17886,8 @@ var ts;
             var specializedIndex = -1;
             var spliceIndex;
             ts.Debug.assert(!result.length);
-            for (var _i = 0; _i < signatures.length; _i++) {
-                var signature = signatures[_i];
+            for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
+                var signature = signatures_2[_i];
                 var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
                 var parent_5 = signature.declaration && signature.declaration.parent;
                 if (!lastSymbol || symbol === lastSymbol) {
@@ -17884,8 +18298,8 @@ var ts;
                 reportError(ts.Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
             }
             if (!produceDiagnostics) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var candidate = candidates[_i];
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
                     if (hasCorrectArity(node, args, candidate)) {
                         if (candidate.typeParameters && typeArguments) {
                             candidate = getSignatureInstantiation(candidate, ts.map(typeArguments, getTypeFromTypeNode));
@@ -17904,8 +18318,8 @@ var ts;
                 diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo));
             }
             function chooseOverload(candidates, relation) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var originalCandidate = candidates[_i];
+                for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+                    var originalCandidate = candidates_2[_i];
                     if (!hasCorrectArity(node, args, originalCandidate)) {
                         continue;
                     }
@@ -18008,7 +18422,7 @@ var ts;
                 return resolveErrorCall(node);
             }
             var valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-            if (valueDecl && valueDecl.flags & 256) {
+            if (valueDecl && valueDecl.flags & 128) {
                 error(node, ts.Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, ts.declarationNameToString(valueDecl.name));
                 return resolveErrorCall(node);
             }
@@ -18294,32 +18708,24 @@ var ts;
             });
             return aggregatedTypes;
         }
-        function bodyContainsAReturnStatement(funcBody) {
-            return ts.forEachReturnStatement(funcBody, function (returnStatement) {
-                return true;
-            });
-        }
-        function bodyContainsSingleThrowStatement(body) {
-            return (body.statements.length === 1) && (body.statements[0].kind === 208);
-        }
-        function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) {
+        function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
             if (!produceDiagnostics) {
                 return;
             }
             if (returnType === voidType || isTypeAny(returnType)) {
                 return;
             }
-            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192) {
+            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192 || !(func.flags & 524288)) {
                 return;
             }
-            var bodyBlock = func.body;
-            if (bodyContainsAReturnStatement(bodyBlock)) {
-                return;
+            if (func.flags & 1048576) {
+                if (compilerOptions.noImplicitReturns) {
+                    error(func.type, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                }
             }
-            if (bodyContainsSingleThrowStatement(bodyBlock)) {
-                return;
+            else {
+                error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
             }
-            error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement);
         }
         function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) {
             ts.Debug.assert(node.kind !== 143 || ts.isObjectLiteralMethod(node));
@@ -18378,7 +18784,7 @@ var ts;
                 promisedType = checkAsyncFunctionReturnType(node);
             }
             if (returnType && !node.asteriskToken) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (node.body) {
                 if (!node.type) {
@@ -18437,7 +18843,7 @@ var ts;
                     case 69:
                     case 166: {
                         var symbol = findSymbol(n);
-                        return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 32768) !== 0;
+                        return symbol && (symbol.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 16384) !== 0;
                     }
                     case 167: {
                         var index = n.argumentExpression;
@@ -18445,7 +18851,7 @@ var ts;
                         if (symbol && index && index.kind === 9) {
                             var name_13 = index.text;
                             var prop = getPropertyOfType(getTypeOfSymbol(symbol), name_13);
-                            return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 32768) !== 0;
+                            return prop && (prop.flags & 3) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 16384) !== 0;
                         }
                         return false;
                     }
@@ -18525,8 +18931,8 @@ var ts;
             }
             if (type.flags & 49152) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
+                    var current = types_9[_i];
                     if (current.flags & kind) {
                         return true;
                     }
@@ -18541,8 +18947,8 @@ var ts;
             }
             if (type.flags & 49152) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
+                    var current = types_10[_i];
                     if (!(current.flags & kind)) {
                         return false;
                     }
@@ -18577,8 +18983,8 @@ var ts;
         }
         function checkObjectLiteralAssignment(node, sourceType, contextualMapper) {
             var properties = node.properties;
-            for (var _i = 0; _i < properties.length; _i++) {
-                var p = properties[_i];
+            for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
+                var p = properties_3[_i];
                 if (p.kind === 245 || p.kind === 246) {
                     var name_14 = p.name;
                     var type = isTypeAny(sourceType)
@@ -19040,7 +19446,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             checkVariableLikeDeclaration(node);
             var func = ts.getContainingFunction(node);
-            if (node.flags & 112) {
+            if (node.flags & 56) {
                 func = ts.getContainingFunction(node);
                 if (!(func.kind === 144 && ts.nodeIsPresent(func.body))) {
                     error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
@@ -19221,7 +19627,7 @@ var ts;
         function checkMethodDeclaration(node) {
             checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name);
             checkFunctionLikeDeclaration(node);
-            if (node.flags & 256 && node.body) {
+            if (node.flags & 128 && node.body) {
                 error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
             }
         }
@@ -19268,7 +19674,7 @@ var ts;
             }
             function isInstancePropertyWithInitializer(n) {
                 return n.kind === 141 &&
-                    !(n.flags & 128) &&
+                    !(n.flags & 64) &&
                     !!n.initializer;
             }
             var containingClassDecl = node.parent;
@@ -19281,12 +19687,12 @@ var ts;
                         error(node, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
                     }
                     var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) ||
-                        ts.forEach(node.parameters, function (p) { return p.flags & (16 | 32 | 64); });
+                        ts.forEach(node.parameters, function (p) { return p.flags & (8 | 16 | 32); });
                     if (superCallShouldBeFirst) {
                         var statements = node.body.statements;
                         var superCallStatement;
-                        for (var _i = 0; _i < statements.length; _i++) {
-                            var statement = statements[_i];
+                        for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
+                            var statement = statements_2[_i];
                             if (statement.kind === 195 && isSuperCallExpression(statement.expression)) {
                                 superCallStatement = statement;
                                 break;
@@ -19312,15 +19718,22 @@ var ts;
             if (produceDiagnostics) {
                 checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
                 if (node.kind === 145) {
-                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) {
-                        error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);
+                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && (node.flags & 524288)) {
+                        if (node.flags & 1048576) {
+                            if (compilerOptions.noImplicitReturns) {
+                                error(node.name, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                            }
+                        }
+                        else {
+                            error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
+                        }
                     }
                 }
                 if (!ts.hasDynamicName(node)) {
                     var otherKind = node.kind === 145 ? 146 : 145;
                     var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind);
                     if (otherAccessor) {
-                        if (((node.flags & 112) !== (otherAccessor.flags & 112))) {
+                        if (((node.flags & 56) !== (otherAccessor.flags & 56))) {
                             error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
                         }
                         var currentAccessorType = getAnnotatedAccessorType(node);
@@ -19387,7 +19800,7 @@ var ts;
             ts.forEach(node.types, checkSourceElement);
         }
         function isPrivateWithinAmbient(node) {
-            return (node.flags & 32) && ts.isInAmbientContext(node);
+            return (node.flags & 16) && ts.isInAmbientContext(node);
         }
         function checkSpecializedSignatureDeclaration(signatureDeclarationNode) {
             if (!produceDiagnostics) {
@@ -19412,8 +19825,8 @@ var ts;
             else {
                 signaturesToCheck = getSignaturesOfSymbol(getSymbolOfNode(signatureDeclarationNode));
             }
-            for (var _i = 0; _i < signaturesToCheck.length; _i++) {
-                var otherSignature = signaturesToCheck[_i];
+            for (var _i = 0, signaturesToCheck_1 = signaturesToCheck; _i < signaturesToCheck_1.length; _i++) {
+                var otherSignature = signaturesToCheck_1[_i];
                 if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) {
                     return;
                 }
@@ -19426,10 +19839,10 @@ var ts;
                 n.parent.kind !== 214 &&
                 n.parent.kind !== 186 &&
                 ts.isInAmbientContext(n)) {
-                if (!(flags & 2)) {
-                    flags |= 1;
+                if (!(flags & 4)) {
+                    flags |= 2;
                 }
-                flags |= 2;
+                flags |= 4;
             }
             return flags & flagsToCheck;
         }
@@ -19447,16 +19860,16 @@ var ts;
                     var canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
                     ts.forEach(overloads, function (o) {
                         var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags;
-                        if (deviation & 1) {
+                        if (deviation & 2) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported);
                         }
-                        else if (deviation & 2) {
+                        else if (deviation & 4) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
                         }
-                        else if (deviation & (32 | 64)) {
+                        else if (deviation & (16 | 32)) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
                         }
-                        else if (deviation & 256) {
+                        else if (deviation & 128) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract);
                         }
                     });
@@ -19473,7 +19886,7 @@ var ts;
                     });
                 }
             }
-            var flagsToCheck = 1 | 2 | 32 | 64 | 256;
+            var flagsToCheck = 2 | 4 | 16 | 32 | 128;
             var someNodeFlags = 0;
             var allNodeFlags = flagsToCheck;
             var someHaveQuestionToken = false;
@@ -19502,8 +19915,8 @@ var ts;
                         var errorNode_1 = subsequentNode.name || subsequentNode;
                         if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) {
                             ts.Debug.assert(node.kind === 143 || node.kind === 142);
-                            ts.Debug.assert((node.flags & 128) !== (subsequentNode.flags & 128));
-                            var diagnostic = node.flags & 128 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
+                            ts.Debug.assert((node.flags & 64) !== (subsequentNode.flags & 64));
+                            var diagnostic = node.flags & 64 ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
                             error(errorNode_1, diagnostic);
                             return;
                         }
@@ -19518,7 +19931,7 @@ var ts;
                     error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing);
                 }
                 else {
-                    if (node.flags & 256) {
+                    if (node.flags & 128) {
                         error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
                     }
                     else {
@@ -19529,8 +19942,8 @@ var ts;
             var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536;
             var duplicateFunctionDeclaration = false;
             var multipleConstructorImplementation = false;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var current = declarations[_i];
+            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                var current = declarations_4[_i];
                 var node = current;
                 var inAmbientContext = ts.isInAmbientContext(node);
                 var inAmbientContextOrInterface = node.parent.kind === 215 || node.parent.kind === 155 || inAmbientContext;
@@ -19579,7 +19992,7 @@ var ts;
                 });
             }
             if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
-                !(lastSeenNonAmbientDeclaration.flags & 256)) {
+                !(lastSeenNonAmbientDeclaration.flags & 128)) {
                 reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
             }
             if (hasOverloads) {
@@ -19589,8 +20002,8 @@ var ts;
                     var signatures = getSignaturesOfSymbol(symbol);
                     var bodySignature = getSignatureFromDeclaration(bodyDeclaration);
                     if (!bodySignature.hasStringLiterals) {
-                        for (var _a = 0; _a < signatures.length; _a++) {
-                            var signature = signatures[_a];
+                        for (var _a = 0, signatures_3 = signatures; _a < signatures_3.length; _a++) {
+                            var signature = signatures_3[_a];
                             if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) {
                                 error(signature.declaration, ts.Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
                                 break;
@@ -19620,9 +20033,9 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var d = _a[_i];
                 var declarationSpaces = getDeclarationSpaces(d);
-                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 | 1024);
-                if (effectiveDeclarationFlags & 1) {
-                    if (effectiveDeclarationFlags & 1024) {
+                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 2 | 512);
+                if (effectiveDeclarationFlags & 2) {
+                    if (effectiveDeclarationFlags & 512) {
                         defaultExportedDeclarationSpaces |= declarationSpaces;
                     }
                     else {
@@ -19758,9 +20171,12 @@ var ts;
             if (promiseType === unknownType && compilerOptions.isolatedModules) {
                 return unknownType;
             }
-            var promiseConstructor = getMergedSymbol(promiseType.symbol);
+            var promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
             if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
-                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType));
+                var typeName = promiseConstructor
+                    ? symbolToString(promiseConstructor)
+                    : typeToString(promiseType);
+                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeName);
                 return unknownType;
             }
             var promiseConstructorType = getTypeOfSymbol(promiseConstructor);
@@ -19919,7 +20335,7 @@ var ts;
                 if (isAsync) {
                     promisedType = checkAsyncFunctionReturnType(node);
                 }
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (produceDiagnostics && !node.type) {
                 if (compilerOptions.noImplicitAny && ts.nodeIsMissing(node.body) && !isPrivateWithinAmbient(node)) {
@@ -20022,7 +20438,7 @@ var ts;
             }
         }
         function checkVarDeclaredNamesNotShadowed(node) {
-            if ((ts.getCombinedNodeFlags(node) & 49152) !== 0 || ts.isParameterDeclaration(node)) {
+            if ((ts.getCombinedNodeFlags(node) & 24576) !== 0 || ts.isParameterDeclaration(node)) {
                 return;
             }
             if (node.kind === 211 && !node.initializer) {
@@ -20034,7 +20450,7 @@ var ts;
                 if (localDeclarationSymbol &&
                     localDeclarationSymbol !== symbol &&
                     localDeclarationSymbol.flags & 2) {
-                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 49152) {
+                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 24576) {
                         var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 212);
                         var container = varDeclList.parent.kind === 193 && varDeclList.parent.parent
                             ? varDeclList.parent.parent
@@ -20161,6 +20577,9 @@ var ts;
             checkGrammarStatementInAmbientContext(node);
             checkExpression(node.expression);
             checkSourceElement(node.thenStatement);
+            if (node.thenStatement.kind === 194) {
+                error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
+            }
             checkSourceElement(node.elseStatement);
         }
         function checkDoStatement(node) {
@@ -20410,7 +20829,7 @@ var ts;
                         error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value);
                     }
                     else if (func.kind === 144) {
-                        if (!isTypeAssignableTo(exprType, returnType)) {
+                        if (!checkTypeAssignableTo(exprType, returnType, node.expression)) {
                             error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
                         }
                     }
@@ -20540,7 +20959,7 @@ var ts;
                     var classDeclaration = type.symbol.valueDeclaration;
                     for (var _i = 0, _a = classDeclaration.members; _i < _a.length; _i++) {
                         var member = _a[_i];
-                        if (!(member.flags & 128) && ts.hasDynamicName(member)) {
+                        if (!(member.flags & 64) && ts.hasDynamicName(member)) {
                             var propType = getTypeOfSymbol(member.symbol);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1);
@@ -20616,7 +21035,7 @@ var ts;
             return getTypeOfSymbol(getSymbolOfNode(node));
         }
         function checkClassDeclaration(node) {
-            if (!node.name && !(node.flags & 1024)) {
+            if (!node.name && !(node.flags & 512)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
             }
             checkClassLikeDeclaration(node);
@@ -20666,8 +21085,8 @@ var ts;
             }
             var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
-                for (var _b = 0; _b < implementedTypeNodes.length; _b++) {
-                    var typeRefNode = implementedTypeNodes[_b];
+                for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
+                    var typeRefNode = implementedTypeNodes_1[_b];
                     if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) {
                         error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
@@ -20699,8 +21118,8 @@ var ts;
         }
         function checkKindsOfPropertyMemberOverrides(type, baseType) {
             var baseProperties = getPropertiesOfObjectType(baseType);
-            for (var _i = 0; _i < baseProperties.length; _i++) {
-                var baseProperty = baseProperties[_i];
+            for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 134217728) {
                     continue;
@@ -20711,7 +21130,7 @@ var ts;
                 if (derived) {
                     if (derived === base) {
                         var derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
-                        if (baseDeclarationFlags & 256 && (!derivedClassDecl || !(derivedClassDecl.flags & 256))) {
+                        if (baseDeclarationFlags & 128 && (!derivedClassDecl || !(derivedClassDecl.flags & 128))) {
                             if (derivedClassDecl.kind === 186) {
                                 error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
                             }
@@ -20722,10 +21141,10 @@ var ts;
                     }
                     else {
                         var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
-                        if ((baseDeclarationFlags & 32) || (derivedDeclarationFlags & 32)) {
+                        if ((baseDeclarationFlags & 16) || (derivedDeclarationFlags & 16)) {
                             continue;
                         }
-                        if ((baseDeclarationFlags & 128) !== (derivedDeclarationFlags & 128)) {
+                        if ((baseDeclarationFlags & 64) !== (derivedDeclarationFlags & 64)) {
                             continue;
                         }
                         if ((base.flags & derived.flags & 8192) || ((base.flags & 98308) && (derived.flags & 98308))) {
@@ -20791,11 +21210,11 @@ var ts;
             var seen = {};
             ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen[p.name] = { prop: p, containingType: type }; });
             var ok = true;
-            for (var _i = 0; _i < baseTypes.length; _i++) {
-                var base = baseTypes[_i];
+            for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
+                var base = baseTypes_2[_i];
                 var properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var prop = properties[_a];
+                for (var _a = 0, properties_4 = properties; _a < properties_4.length; _a++) {
+                    var prop = properties_4[_a];
                     if (!ts.hasProperty(seen, prop.name)) {
                         seen[prop.name] = { prop: prop, containingType: base };
                     }
@@ -21064,8 +21483,8 @@ var ts;
         }
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
             var declarations = symbol.declarations;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+                var declaration = declarations_5[_i];
                 if ((declaration.kind === 214 ||
                     (declaration.kind === 213 && ts.nodeIsPresent(declaration.body))) &&
                     !ts.isInAmbientContext(declaration)) {
@@ -21193,7 +21612,7 @@ var ts;
             if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_import_declaration_can_only_be_used_in_a_namespace_or_module)) {
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
             }
             if (checkExternalImportOrExportDeclaration(node)) {
@@ -21220,7 +21639,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
                 checkImportBinding(node);
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     markExportAsReferenced(node);
                 }
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
@@ -21248,7 +21667,7 @@ var ts;
             if (checkGrammarModuleElementContext(node, ts.Diagnostics.An_export_declaration_can_only_be_used_in_a_module)) {
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
             }
             if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
@@ -21287,7 +21706,7 @@ var ts;
                 error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
             }
             if (node.expression.kind === 69) {
@@ -21672,7 +22091,7 @@ var ts;
                             }
                         case 214:
                         case 215:
-                            if (!(memberFlags & 128)) {
+                            if (!(memberFlags & 64)) {
                                 copySymbols(getSymbolOfNode(location).members, meaning & 793056);
                             }
                             break;
@@ -21934,7 +22353,7 @@ var ts;
         }
         function getParentTypeOfClassElement(node) {
             var classSymbol = getSymbolOfNode(node.parent);
-            return node.flags & 128
+            return node.flags & 64
                 ? getTypeOfSymbol(classSymbol)
                 : getDeclaredTypeOfSymbol(classSymbol);
         }
@@ -22220,7 +22639,7 @@ var ts;
         }
         function initializeTypeChecker() {
             ts.forEach(host.getSourceFiles(), function (file) {
-                ts.bindSourceFile(file);
+                ts.bindSourceFile(file, compilerOptions);
             });
             ts.forEach(host.getSourceFiles(), function (file) {
                 if (!ts.isExternalModule(file)) {
@@ -22364,19 +22783,19 @@ var ts;
                             text = "private";
                             lastPrivate = modifier;
                         }
-                        if (flags & 112) {
+                        if (flags & 56) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
                         }
-                        else if (flags & 128) {
+                        else if (flags & 64) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
                         }
                         else if (node.parent.kind === 219 || node.parent.kind === 248) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text);
                         }
-                        else if (flags & 256) {
+                        else if (flags & 128) {
                             if (modifier.kind === 110) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
                             }
@@ -22387,10 +22806,10 @@ var ts;
                         flags |= ts.modifierToFlag(modifier.kind);
                         break;
                     case 113:
-                        if (flags & 128) {
+                        if (flags & 64) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
                         }
                         else if (node.parent.kind === 219 || node.parent.kind === 248) {
@@ -22399,23 +22818,23 @@ var ts;
                         else if (node.kind === 138) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
                         }
-                        else if (flags & 256) {
+                        else if (flags & 128) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                         }
-                        flags |= 128;
+                        flags |= 64;
                         lastStatic = modifier;
                         break;
                     case 82:
-                        if (flags & 1) {
+                        if (flags & 2) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
                         }
-                        else if (flags & 2) {
+                        else if (flags & 4) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
                         }
-                        else if (flags & 256) {
+                        else if (flags & 128) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
                         }
                         else if (node.parent.kind === 214) {
@@ -22424,13 +22843,13 @@ var ts;
                         else if (node.kind === 138) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
                         }
-                        flags |= 1;
+                        flags |= 2;
                         break;
                     case 122:
-                        if (flags & 2) {
+                        if (flags & 4) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
                         }
-                        else if (flags & 512) {
+                        else if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.parent.kind === 214) {
@@ -22442,69 +22861,69 @@ var ts;
                         else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 219) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
                         }
-                        flags |= 2;
+                        flags |= 4;
                         lastDeclare = modifier;
                         break;
                     case 115:
-                        if (flags & 256) {
+                        if (flags & 128) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
                         }
                         if (node.kind !== 214) {
                             if (node.kind !== 143) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_or_method_declaration);
                             }
-                            if (!(node.parent.kind === 214 && node.parent.flags & 256)) {
+                            if (!(node.parent.kind === 214 && node.parent.flags & 128)) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
                             }
-                            if (flags & 128) {
+                            if (flags & 64) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                             }
-                            if (flags & 32) {
+                            if (flags & 16) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
                             }
                         }
-                        flags |= 256;
+                        flags |= 128;
                         break;
                     case 118:
-                        if (flags & 512) {
+                        if (flags & 256) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
                         }
-                        else if (flags & 2 || ts.isInAmbientContext(node.parent)) {
+                        else if (flags & 4 || ts.isInAmbientContext(node.parent)) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.kind === 138) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
                         }
-                        flags |= 512;
+                        flags |= 256;
                         lastAsync = modifier;
                         break;
                 }
             }
             if (node.kind === 144) {
-                if (flags & 128) {
+                if (flags & 64) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
                 }
-                if (flags & 256) {
+                if (flags & 128) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
                 }
-                else if (flags & 64) {
+                else if (flags & 32) {
                     return grammarErrorOnNode(lastProtected, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected");
                 }
-                else if (flags & 32) {
+                else if (flags & 16) {
                     return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private");
                 }
-                else if (flags & 512) {
+                else if (flags & 256) {
                     return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
                 }
                 return;
             }
-            else if ((node.kind === 222 || node.kind === 221) && flags & 2) {
+            else if ((node.kind === 222 || node.kind === 221) && flags & 4) {
                 return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
             }
-            else if (node.kind === 138 && (flags & 112) && ts.isBindingPattern(node.name)) {
+            else if (node.kind === 138 && (flags & 56) && ts.isBindingPattern(node.name)) {
                 return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern);
             }
-            if (flags & 512) {
+            if (flags & 256) {
                 return checkGrammarAsyncModifier(node, lastAsync);
             }
         }
@@ -22604,7 +23023,7 @@ var ts;
             if (parameter.dotDotDotToken) {
                 return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
             }
-            if (parameter.flags & 2035) {
+            if (parameter.flags & 1022) {
                 return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
             }
             if (parameter.questionToken) {
@@ -22624,7 +23043,7 @@ var ts;
             }
         }
         function checkGrammarForIndexSignatureModifier(node) {
-            if (node.flags & 2035) {
+            if (node.flags & 1022) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_not_permitted_on_index_signature_members);
             }
         }
@@ -22646,8 +23065,8 @@ var ts;
         function checkGrammarForOmittedArgument(node, args) {
             if (args) {
                 var sourceFile = ts.getSourceFileOfNode(node);
-                for (var _i = 0; _i < args.length; _i++) {
-                    var arg = args[_i];
+                for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+                    var arg = args_1[_i];
                     if (arg.kind === 187) {
                         return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
                     }
@@ -22887,7 +23306,7 @@ var ts;
                     if (parameter.dotDotDotToken) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
                     }
-                    else if (parameter.flags & 2035) {
+                    else if (parameter.flags & 1022) {
                         return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
                     }
                     else if (parameter.questionToken) {
@@ -23021,8 +23440,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0; _i < elements.length; _i++) {
-                    var element = elements[_i];
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
                     if (element.kind !== 187) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -23141,8 +23560,8 @@ var ts;
                 node.kind === 221 ||
                 node.kind === 228 ||
                 node.kind === 227 ||
-                (node.flags & 2) ||
-                (node.flags & (1 | 1024))) {
+                (node.flags & 4) ||
+                (node.flags & (2 | 512))) {
                 return false;
             }
             return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
@@ -23180,7 +23599,7 @@ var ts;
             }
         }
         function checkGrammarNumericLiteral(node) {
-            if (node.flags & 65536 && languageVersion >= 1) {
+            if (node.flags & 32768 && languageVersion >= 1) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
             }
         }
@@ -23227,7 +23646,7 @@ var ts;
                 var addedGlobalFileReference = false;
                 ts.forEach(root.referencedFiles, function (fileReference) {
                     var referencedFile = ts.tryResolveScriptReference(host, root, fileReference);
-                    if (referencedFile && ((referencedFile.flags & 8192) ||
+                    if (referencedFile && ((referencedFile.flags & 4096) ||
                         ts.shouldEmitToOwnFile(referencedFile, compilerOptions) ||
                         !addedGlobalFileReference)) {
                         writeReferencePath(referencedFile);
@@ -23405,15 +23824,15 @@ var ts;
             }
         }
         function emitLines(nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                var node = nodes_2[_i];
                 emit(node);
             }
         }
         function emitSeparatedList(nodes, separator, eachNodeEmitFn, canEmitFn) {
             var currentWriterPos = writer.getTextPos();
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+                var node = nodes_3[_i];
                 if (!canEmitFn || canEmitFn(node)) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         write(separator);
@@ -23555,6 +23974,7 @@ var ts;
         function emitSourceFile(node) {
             currentSourceFile = node;
             enclosingDeclaration = node;
+            ts.emitDetachedComments(currentSourceFile, writer, ts.writeCommentRange, node, newLine, true);
             emitLines(node.statements);
         }
         function getExportDefaultTempVariableName() {
@@ -23661,10 +24081,10 @@ var ts;
         }
         function emitModuleElementDeclarationFlags(node) {
             if (node.parent === currentSourceFile) {
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     write("export ");
                 }
-                if (node.flags & 1024) {
+                if (node.flags & 512) {
                     write("default ");
                 }
                 else if (node.kind !== 215) {
@@ -23673,22 +24093,22 @@ var ts;
             }
         }
         function emitClassMemberDeclarationFlags(node) {
-            if (node.flags & 32) {
+            if (node.flags & 16) {
                 write("private ");
             }
-            else if (node.flags & 64) {
+            else if (node.flags & 32) {
                 write("protected ");
             }
-            if (node.flags & 128) {
+            if (node.flags & 64) {
                 write("static ");
             }
-            if (node.flags & 256) {
+            if (node.flags & 128) {
                 write("abstract ");
             }
         }
         function writeImportEqualsDeclaration(node) {
             emitJsDocComments(node);
-            if (node.flags & 1) {
+            if (node.flags & 2) {
                 write("export ");
             }
             write("import ");
@@ -23723,11 +24143,11 @@ var ts;
             }
         }
         function writeImportDeclaration(node) {
-            if (!node.importClause && !(node.flags & 1)) {
+            if (!node.importClause && !(node.flags & 2)) {
                 return;
             }
             emitJsDocComments(node);
-            if (node.flags & 1) {
+            if (node.flags & 2) {
                 write("export ");
             }
             write("import ");
@@ -23789,7 +24209,7 @@ var ts;
         function writeModuleDeclaration(node) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 131072) {
+            if (node.flags & 65536) {
                 write("namespace ");
             }
             else {
@@ -23861,7 +24281,7 @@ var ts;
             writeLine();
         }
         function isPrivateMethodTypeParameter(node) {
-            return node.parent.kind === 143 && (node.parent.flags & 32);
+            return node.parent.kind === 143 && (node.parent.flags & 16);
         }
         function emitTypeParameters(typeParameters) {
             function emitTypeParameter(node) {
@@ -23903,7 +24323,7 @@ var ts;
                             break;
                         case 143:
                         case 142:
-                            if (node.parent.flags & 128) {
+                            if (node.parent.flags & 64) {
                                 diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                             }
                             else if (node.parent.parent.kind === 214) {
@@ -23966,7 +24386,7 @@ var ts;
             function emitParameterProperties(constructorDeclaration) {
                 if (constructorDeclaration) {
                     ts.forEach(constructorDeclaration.parameters, function (param) {
-                        if (param.flags & 112) {
+                        if (param.flags & 56) {
                             emitPropertyDeclaration(param);
                         }
                     });
@@ -23974,7 +24394,7 @@ var ts;
             }
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 256) {
+            if (node.flags & 128) {
                 write("abstract ");
             }
             write("class ");
@@ -24038,7 +24458,7 @@ var ts;
                     if ((node.kind === 141 || node.kind === 140) && node.parent.kind === 155) {
                         emitTypeOfVariableDeclarationFromTypeLiteral(node);
                     }
-                    else if (!(node.flags & 32)) {
+                    else if (!(node.flags & 16)) {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
@@ -24052,7 +24472,7 @@ var ts;
                         ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
                 }
                 else if (node.kind === 141 || node.kind === 140) {
-                    if (node.flags & 128) {
+                    if (node.flags & 64) {
                         return symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 ?
                                 ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -24147,7 +24567,7 @@ var ts;
                 emitJsDocComments(accessors.setAccessor);
                 emitClassMemberDeclarationFlags(node);
                 writeTextOfNode(currentSourceFile, node.name);
-                if (!(node.flags & 32)) {
+                if (!(node.flags & 16)) {
                     accessorWithTypeAnnotation = node;
                     var type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
@@ -24174,7 +24594,7 @@ var ts;
             function getAccessorDeclarationTypeVisibilityError(symbolAccesibilityResult) {
                 var diagnosticMessage;
                 if (accessorWithTypeAnnotation.kind === 146) {
-                    if (accessorWithTypeAnnotation.parent.flags & 128) {
+                    if (accessorWithTypeAnnotation.parent.flags & 64) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
@@ -24191,7 +24611,7 @@ var ts;
                     };
                 }
                 else {
-                    if (accessorWithTypeAnnotation.flags & 128) {
+                    if (accessorWithTypeAnnotation.flags & 64) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 ?
                                 ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -24272,7 +24692,7 @@ var ts;
                     emitType(node.type);
                 }
             }
-            else if (node.kind !== 144 && !(node.flags & 32)) {
+            else if (node.kind !== 144 && !(node.flags & 16)) {
                 writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
             }
             enclosingDeclaration = prevEnclosingDeclaration;
@@ -24300,7 +24720,7 @@ var ts;
                         break;
                     case 143:
                     case 142:
-                        if (node.flags & 128) {
+                        if (node.flags & 64) {
                             diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 ?
                                     ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -24357,7 +24777,7 @@ var ts;
                 node.parent.parent.kind === 155) {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
-            else if (!(node.parent.flags & 32)) {
+            else if (!(node.parent.flags & 16)) {
                 writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
             }
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) {
@@ -24386,7 +24806,7 @@ var ts;
                             ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
                     case 143:
                     case 142:
-                        if (node.parent.flags & 128) {
+                        if (node.parent.flags & 64) {
                             return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 ?
                                     ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -24502,7 +24922,7 @@ var ts;
             }
         }
         function writeReferencePath(referencedFile) {
-            var declFileName = referencedFile.flags & 8192
+            var declFileName = referencedFile.flags & 4096
                 ? referencedFile.fileName
                 : ts.shouldEmitToOwnFile(referencedFile, compilerOptions)
                     ? ts.getOwnEmitOutputFilePath(referencedFile, host, ".d.ts")
@@ -24835,16 +25255,8 @@ var ts;
             diagnostics: diagnostics,
             sourceMaps: sourceMapDataList
         };
-        function isNodeDescendentOf(node, ancestor) {
-            while (node) {
-                if (node === ancestor)
-                    return true;
-                node = node.parent;
-            }
-            return false;
-        }
         function isUniqueLocalName(name, container) {
-            for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {
+            for (var node = container; ts.isNodeDescendentOf(node, container); node = node.nextContainer) {
                 if (node.locals && ts.hasProperty(node.locals, name)) {
                     if (node.locals[name].flags & (107455 | 1048576 | 8388608)) {
                         return false;
@@ -26137,7 +26549,7 @@ var ts;
                     write("]");
                 }
                 else {
-                    emitListWithSpread(elements, true, (node.flags & 2048) !== 0, elements.hasTrailingComma, true);
+                    emitListWithSpread(elements, true, (node.flags & 1024) !== 0, elements.hasTrailingComma, true);
                 }
             }
             function emitObjectLiteralBody(node, numElements) {
@@ -26152,7 +26564,7 @@ var ts;
                         emitLinePreservingList(node, properties, languageVersion >= 1, true);
                     }
                     else {
-                        var multiLine = (node.flags & 2048) !== 0;
+                        var multiLine = (node.flags & 1024) !== 0;
                         if (!multiLine) {
                             write(" ");
                         }
@@ -26171,7 +26583,7 @@ var ts;
                 write("}");
             }
             function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) {
-                var multiLine = (node.flags & 2048) !== 0;
+                var multiLine = (node.flags & 1024) !== 0;
                 var properties = node.properties;
                 write("(");
                 if (multiLine) {
@@ -26689,7 +27101,7 @@ var ts;
                 var current = node;
                 while (current) {
                     if (current.kind === 248) {
-                        return !isExported || ((ts.getCombinedNodeFlags(node) & 1) !== 0);
+                        return !isExported || ((ts.getCombinedNodeFlags(node) & 2) !== 0);
                     }
                     else if (ts.isFunctionLike(current) || current.kind === 219) {
                         return false;
@@ -26907,7 +27319,7 @@ var ts;
                 if (shouldHoistVariable(decl, true)) {
                     return false;
                 }
-                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 49152) === 0) {
+                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 24576) === 0) {
                     for (var _a = 0, _b = decl.declarations; _a < _b.length; _a++) {
                         var varDecl = _b[_a];
                         hoistVariableDeclarationFromLoop(convertedLoopState, varDecl);
@@ -26989,7 +27401,7 @@ var ts;
                         break;
                 }
                 var loopParameters;
-                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 49152)) {
+                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 24576)) {
                     loopParameters = [];
                     for (var _a = 0, _b = loopInitializer.declarations; _a < _b.length; _a++) {
                         var varDeclaration = _b[_a];
@@ -27246,22 +27658,22 @@ var ts;
                 var endPos = emitToken(86, node.pos);
                 write(" ");
                 endPos = emitToken(17, endPos);
-                var rhsIsIdentifier = node.expression.kind === 69;
                 var counter = createTempVariable(268435456);
-                var rhsReference = rhsIsIdentifier ? node.expression : createTempVariable(0);
+                var rhsReference = ts.createSynthesizedNode(69);
+                rhsReference.text = node.expression.kind === 69 ?
+                    makeUniqueName(node.expression.text) :
+                    makeTempVariableName(0);
                 emitStart(node.expression);
                 write("var ");
                 emitNodeWithoutSourceMap(counter);
                 write(" = 0");
                 emitEnd(node.expression);
-                if (!rhsIsIdentifier) {
-                    write(", ");
-                    emitStart(node.expression);
-                    emitNodeWithoutSourceMap(rhsReference);
-                    write(" = ");
-                    emitNodeWithoutSourceMap(node.expression);
-                    emitEnd(node.expression);
-                }
+                write(", ");
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(rhsReference);
+                write(" = ");
+                emitNodeWithoutSourceMap(node.expression);
+                emitEnd(node.expression);
                 write("; ");
                 emitStart(node.initializer);
                 emitNodeWithoutSourceMap(counter);
@@ -27496,7 +27908,7 @@ var ts;
             }
             function emitModuleMemberName(node) {
                 emitStart(node.name);
-                if (ts.getCombinedNodeFlags(node) & 1) {
+                if (ts.getCombinedNodeFlags(node) & 2) {
                     var container = getContainingModule(node);
                     if (container) {
                         write(getGeneratedNameForNode(container));
@@ -27518,7 +27930,7 @@ var ts;
             }
             function emitEs6ExportDefaultCompat(node) {
                 if (node.parent.kind === 248) {
-                    ts.Debug.assert(!!(node.flags & 1024) || node.kind === 227);
+                    ts.Debug.assert(!!(node.flags & 512) || node.kind === 227);
                     if (modulekind === 1 || modulekind === 2 || modulekind === 3) {
                         if (!currentSourceFile.symbol.exports["___esModule"]) {
                             if (languageVersion === 1) {
@@ -27534,12 +27946,12 @@ var ts;
                 }
             }
             function emitExportMemberAssignment(node) {
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     writeLine();
                     emitStart(node);
                     if (modulekind === 4 && node.parent === currentSourceFile) {
                         write(exportFunctionForFile + "(\"");
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             write("default");
                         }
                         else {
@@ -27550,7 +27962,7 @@ var ts;
                         write(")");
                     }
                     else {
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             emitEs6ExportDefaultCompat(node);
                             if (languageVersion === 0) {
                                 write("exports[\"default\"]");
@@ -27638,7 +28050,7 @@ var ts;
                 var emitCount = 0;
                 var canDefineTempVariablesInPlace = false;
                 if (root.kind === 211) {
-                    var isExported = ts.getCombinedNodeFlags(root) & 1;
+                    var isExported = ts.getCombinedNodeFlags(root) & 2;
                     var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
                     canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind;
                 }
@@ -27704,8 +28116,8 @@ var ts;
                     if (properties.length !== 1) {
                         value = ensureIdentifier(value, true);
                     }
-                    for (var _a = 0; _a < properties.length; _a++) {
-                        var p = properties[_a];
+                    for (var _a = 0, properties_5 = properties; _a < properties_5.length; _a++) {
+                        var p = properties_5[_a];
                         if (p.kind === 245 || p.kind === 246) {
                             var propName = p.name;
                             var target_1 = p.kind === 246 ? p : p.initializer || propName;
@@ -27824,7 +28236,7 @@ var ts;
                     var initializer = node.initializer;
                     if (!initializer && languageVersion < 2) {
                         var isLetDefinedInLoop = (resolver.getNodeCheckFlags(node) & 16384) &&
-                            (getCombinedFlagsForIdentifier(node.name) & 16384);
+                            (getCombinedFlagsForIdentifier(node.name) & 8192);
                         if (isLetDefinedInLoop &&
                             node.parent.parent.kind !== 200 &&
                             node.parent.parent.kind !== 201) {
@@ -27863,13 +28275,13 @@ var ts;
                 return ts.getCombinedNodeFlags(node.parent);
             }
             function isES6ExportedDeclaration(node) {
-                return !!(node.flags & 1) &&
+                return !!(node.flags & 2) &&
                     modulekind === 5 &&
                     node.parent.kind === 248;
             }
             function emitVariableStatement(node) {
                 var startIsEmitted = false;
-                if (node.flags & 1) {
+                if (node.flags & 2) {
                     if (isES6ExportedDeclaration(node)) {
                         write("export ");
                         startIsEmitted = tryEmitStartOfVariableDeclarationList(node.declarationList);
@@ -27893,7 +28305,7 @@ var ts;
                 }
             }
             function shouldEmitLeadingAndTrailingCommentsForVariableStatement(node) {
-                if (!(node.flags & 1)) {
+                if (!(node.flags & 2)) {
                     return true;
                 }
                 if (isES6ExportedDeclaration(node)) {
@@ -28050,7 +28462,7 @@ var ts;
                 if (!shouldEmitAsArrowFunction(node)) {
                     if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             write("default ");
                         }
                     }
@@ -28189,7 +28601,7 @@ var ts;
                 emitRestParameter(node);
             }
             function emitExpressionFunctionBody(node, body) {
-                if (languageVersion < 2 || node.flags & 512) {
+                if (languageVersion < 2 || node.flags & 256) {
                     emitDownLevelExpressionFunctionBody(node, body);
                     return;
                 }
@@ -28205,7 +28617,7 @@ var ts;
                 scopeEmitStart(node);
                 increaseIndent();
                 var outPos = writer.getTextPos();
-                emitDetachedComments(node.body);
+                emitDetachedCommentsAndUpdateCommentsInfo(node.body);
                 emitFunctionBodyPreamble(node);
                 var preambleEmitted = writer.getTextPos() !== outPos;
                 decreaseIndent();
@@ -28241,7 +28653,7 @@ var ts;
                 scopeEmitStart(node);
                 var initialTextPos = writer.getTextPos();
                 increaseIndent();
-                emitDetachedComments(body.statements);
+                emitDetachedCommentsAndUpdateCommentsInfo(body.statements);
                 var startIndex = emitDirectivePrologues(body.statements, true);
                 emitFunctionBodyPreamble(node);
                 decreaseIndent();
@@ -28283,7 +28695,7 @@ var ts;
             }
             function emitParameterPropertyAssignments(node) {
                 ts.forEach(node.parameters, function (param) {
-                    if (param.flags & 112) {
+                    if (param.flags & 56) {
                         writeLine();
                         emitStart(param);
                         emitStart(param.name);
@@ -28315,15 +28727,15 @@ var ts;
                 var properties = [];
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
-                    if (member.kind === 141 && isStatic === ((member.flags & 128) !== 0) && member.initializer) {
+                    if (member.kind === 141 && isStatic === ((member.flags & 64) !== 0) && member.initializer) {
                         properties.push(member);
                     }
                 }
                 return properties;
             }
             function emitPropertyDeclarations(node, properties) {
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var property = properties[_a];
+                for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
+                    var property = properties_6[_a];
                     emitPropertyDeclaration(node, property);
                 }
             }
@@ -28336,7 +28748,7 @@ var ts;
                     emit(receiver);
                 }
                 else {
-                    if (property.flags & 128) {
+                    if (property.flags & 64) {
                         emitDeclarationName(node);
                     }
                     else {
@@ -28435,7 +28847,7 @@ var ts;
                         writeLine();
                         emitLeadingComments(member);
                         emitStart(member);
-                        if (member.flags & 128) {
+                        if (member.flags & 64) {
                             write("static ");
                         }
                         if (member.kind === 145) {
@@ -28480,7 +28892,7 @@ var ts;
                     if (member.kind === 144 && !member.body) {
                         emitCommentsOnNotEmittedNode(member);
                     }
-                    if (member.kind === 141 && member.initializer && (member.flags & 128) === 0) {
+                    if (member.kind === 141 && member.initializer && (member.flags & 64) === 0) {
                         hasInstancePropertyWithInitializer = true;
                     }
                 });
@@ -28517,7 +28929,7 @@ var ts;
                 increaseIndent();
                 if (ctor) {
                     startIndex = emitDirectivePrologues(ctor.body.statements, true);
-                    emitDetachedComments(ctor.body.statements);
+                    emitDetachedCommentsAndUpdateCommentsInfo(ctor.body.statements);
                 }
                 emitCaptureThisForNodeIfNecessary(node);
                 var superCall;
@@ -28588,7 +29000,7 @@ var ts;
                 var thisNodeIsDecorated = ts.nodeIsDecorated(node);
                 if (node.kind === 214) {
                     if (thisNodeIsDecorated) {
-                        if (isES6ExportedDeclaration(node) && !(node.flags & 1024)) {
+                        if (isES6ExportedDeclaration(node) && !(node.flags & 512)) {
                             write("export ");
                         }
                         write("let ");
@@ -28597,7 +29009,7 @@ var ts;
                     }
                     else if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024) {
+                        if (node.flags & 512) {
                             write("default ");
                         }
                     }
@@ -28613,7 +29025,7 @@ var ts;
                     write(" = ");
                 }
                 write("class");
-                if ((node.name || (node.flags & 1024 && staticProperties.length > 0)) && !thisNodeIsDecorated) {
+                if ((node.name || (node.flags & 512 && staticProperties.length > 0)) && !thisNodeIsDecorated) {
                     write(" ");
                     emitDeclarationName(node);
                 }
@@ -28636,8 +29048,8 @@ var ts;
                     write(";");
                 }
                 if (isClassExpressionWithStaticProperties) {
-                    for (var _a = 0; _a < staticProperties.length; _a++) {
-                        var property = staticProperties[_a];
+                    for (var _a = 0, staticProperties_1 = staticProperties; _a < staticProperties_1.length; _a++) {
+                        var property = staticProperties_1[_a];
                         write(",");
                         writeLine();
                         emitPropertyDeclaration(node, property, tempVariable, true);
@@ -28653,7 +29065,7 @@ var ts;
                     emitPropertyDeclarations(node, staticProperties);
                     emitDecoratorsOfClass(node);
                 }
-                if (!isES6ExportedDeclaration(node) && (node.flags & 1)) {
+                if (!isES6ExportedDeclaration(node) && (node.flags & 2)) {
                     writeLine();
                     emitStart(node);
                     emitModuleMemberName(node);
@@ -28662,7 +29074,7 @@ var ts;
                     emitEnd(node);
                     write(";");
                 }
-                else if (isES6ExportedDeclaration(node) && (node.flags & 1024) && thisNodeIsDecorated) {
+                else if (isES6ExportedDeclaration(node) && (node.flags & 512) && thisNodeIsDecorated) {
                     writeLine();
                     write("export default ");
                     emitDeclarationName(node);
@@ -28742,13 +29154,13 @@ var ts;
             }
             function emitClassMemberPrefix(node, member) {
                 emitDeclarationName(node);
-                if (!(member.flags & 128)) {
+                if (!(member.flags & 64)) {
                     write(".prototype");
                 }
             }
             function emitDecoratorsOfClass(node) {
                 emitDecoratorsOfMembers(node, 0);
-                emitDecoratorsOfMembers(node, 128);
+                emitDecoratorsOfMembers(node, 64);
                 emitDecoratorsOfConstructor(node);
             }
             function emitDecoratorsOfConstructor(node) {
@@ -28783,7 +29195,7 @@ var ts;
             function emitDecoratorsOfMembers(node, staticFlag) {
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
-                    if ((member.flags & 128) !== staticFlag) {
+                    if ((member.flags & 64) !== staticFlag) {
                         continue;
                     }
                     if (!ts.nodeCanBeDecorated(member)) {
@@ -29110,7 +29522,7 @@ var ts;
                     return;
                 }
                 if (!shouldHoistDeclarationInSystemJsModule(node)) {
-                    if (!(node.flags & 1) || isES6ExportedDeclaration(node)) {
+                    if (!(node.flags & 2) || isES6ExportedDeclaration(node)) {
                         emitStart(node);
                         if (isES6ExportedDeclaration(node)) {
                             write("export ");
@@ -29141,7 +29553,7 @@ var ts;
                 emitModuleMemberName(node);
                 write(" = {}));");
                 emitEnd(node);
-                if (!isES6ExportedDeclaration(node) && node.flags & 1 && !shouldHoistDeclarationInSystemJsModule(node)) {
+                if (!isES6ExportedDeclaration(node) && node.flags & 2 && !shouldHoistDeclarationInSystemJsModule(node)) {
                     writeLine();
                     emitStart(node);
                     write("var ");
@@ -29152,7 +29564,7 @@ var ts;
                     write(";");
                 }
                 if (modulekind !== 5 && node.parent === currentSourceFile) {
-                    if (modulekind === 4 && (node.flags & 1)) {
+                    if (modulekind === 4 && (node.flags & 2)) {
                         writeLine();
                         write(exportFunctionForFile + "(\"");
                         emitDeclarationName(node);
@@ -29254,7 +29666,7 @@ var ts;
                     scopeEmitEnd();
                 }
                 write(")(");
-                if ((node.flags & 1) && !isES6ExportedDeclaration(node)) {
+                if ((node.flags & 2) && !isES6ExportedDeclaration(node)) {
                     emit(node.name);
                     write(" = ");
                 }
@@ -29264,7 +29676,7 @@ var ts;
                 write(" = {}));");
                 emitEnd(node);
                 if (!isES6ExportedDeclaration(node) && node.name.kind === 69 && node.parent === currentSourceFile) {
-                    if (modulekind === 4 && (node.flags & 1)) {
+                    if (modulekind === 4 && (node.flags & 2)) {
                         writeLine();
                         write(exportFunctionForFile + "(\"");
                         emitDeclarationName(node);
@@ -29362,7 +29774,7 @@ var ts;
             }
             function emitExternalImportDeclaration(node) {
                 if (ts.contains(externalImports, node)) {
-                    var isExportedImport = node.kind === 221 && (node.flags & 1) !== 0;
+                    var isExportedImport = node.kind === 221 && (node.flags & 2) !== 0;
                     var namespaceDeclaration = getNamespaceDeclarationNode(node);
                     if (modulekind !== 2) {
                         emitLeadingComments(node);
@@ -29428,7 +29840,7 @@ var ts;
                             write("export ");
                             write("var ");
                         }
-                        else if (!(node.flags & 1)) {
+                        else if (!(node.flags & 2)) {
                             write("var ");
                         }
                     }
@@ -29516,8 +29928,8 @@ var ts;
             function emitExportOrImportSpecifierList(specifiers, shouldEmit) {
                 ts.Debug.assert(modulekind === 5);
                 var needsComma = false;
-                for (var _a = 0; _a < specifiers.length; _a++) {
-                    var specifier = specifiers[_a];
+                for (var _a = 0, specifiers_1 = specifiers; _a < specifiers_1.length; _a++) {
+                    var specifier = specifiers_1[_a];
                     if (shouldEmit(specifier)) {
                         if (needsComma) {
                             write(", ");
@@ -29651,8 +30063,8 @@ var ts;
                 }
                 writeLine();
                 var started = false;
-                for (var _a = 0; _a < externalImports.length; _a++) {
-                    var importNode = externalImports[_a];
+                for (var _a = 0, externalImports_1 = externalImports; _a < externalImports_1.length; _a++) {
+                    var importNode = externalImports_1[_a];
                     var skipNode = importNode.kind === 228 ||
                         (importNode.kind === 222 && !importNode.importClause);
                     if (skipNode) {
@@ -29677,8 +30089,8 @@ var ts;
                 }
                 if (!exportedDeclarations && ts.isEmpty(exportSpecifiers)) {
                     var hasExportDeclarationWithExportClause = false;
-                    for (var _a = 0; _a < externalImports.length; _a++) {
-                        var externalImport = externalImports[_a];
+                    for (var _a = 0, externalImports_2 = externalImports; _a < externalImports_2.length; _a++) {
+                        var externalImport = externalImports_2[_a];
                         if (externalImport.kind === 228 && externalImport.exportClause) {
                             hasExportDeclarationWithExportClause = true;
                             break;
@@ -29706,8 +30118,8 @@ var ts;
                         }
                     }
                 }
-                for (var _d = 0; _d < externalImports.length; _d++) {
-                    var externalImport = externalImports[_d];
+                for (var _d = 0, externalImports_3 = externalImports; _d < externalImports_3.length; _d++) {
+                    var externalImport = externalImports_3[_d];
                     if (externalImport.kind !== 228) {
                         continue;
                     }
@@ -29751,7 +30163,7 @@ var ts;
                     return exportStarFunction;
                 }
                 function writeExportedName(node) {
-                    if (node.kind !== 69 && node.flags & 1024) {
+                    if (node.kind !== 69 && node.flags & 512) {
                         return;
                     }
                     if (started) {
@@ -29804,7 +30216,7 @@ var ts;
                             emit(local);
                         }
                         var flags = ts.getCombinedNodeFlags(local.kind === 69 ? local.parent : local);
-                        if (flags & 1) {
+                        if (flags & 2) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -29814,11 +30226,11 @@ var ts;
                     write(";");
                 }
                 if (hoistedFunctionDeclarations) {
-                    for (var _a = 0; _a < hoistedFunctionDeclarations.length; _a++) {
-                        var f = hoistedFunctionDeclarations[_a];
+                    for (var _a = 0, hoistedFunctionDeclarations_1 = hoistedFunctionDeclarations; _a < hoistedFunctionDeclarations_1.length; _a++) {
+                        var f = hoistedFunctionDeclarations_1[_a];
                         writeLine();
                         emit(f);
-                        if (f.flags & 1) {
+                        if (f.flags & 2) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -29828,7 +30240,7 @@ var ts;
                 }
                 return exportedDeclarations;
                 function visit(node) {
-                    if (node.flags & 2) {
+                    if (node.flags & 4) {
                         return;
                     }
                     if (node.kind === 213) {
@@ -29898,7 +30310,7 @@ var ts;
                 if (checkIfSourceFileLevelDecl && !shouldHoistDeclarationInSystemJsModule(node)) {
                     return false;
                 }
-                return (ts.getCombinedNodeFlags(node) & 49152) === 0 ||
+                return (ts.getCombinedNodeFlags(node) & 24576) === 0 ||
                     ts.getEnclosingBlockScopeContainer(node).kind === 248;
             }
             function isCurrentFileSystemExternalModule() {
@@ -29933,8 +30345,8 @@ var ts;
                     var parameterName = makeUniqueName(ts.forEach(group, getLocalNameForExternalImport) || "");
                     write("function (" + parameterName + ") {");
                     increaseIndent();
-                    for (var _a = 0; _a < group.length; _a++) {
-                        var entry = group[_a];
+                    for (var _a = 0, group_1 = group; _a < group_1.length; _a++) {
+                        var entry = group_1[_a];
                         var importVariableName = getLocalNameForExternalImport(entry) || "";
                         switch (entry.kind) {
                             case 222:
@@ -30068,8 +30480,8 @@ var ts;
                         unaliasedModuleNames.push("\"" + amdDependency.path + "\"");
                     }
                 }
-                for (var _c = 0; _c < externalImports.length; _c++) {
-                    var importNode = externalImports[_c];
+                for (var _c = 0, externalImports_4 = externalImports; _c < externalImports_4.length; _c++) {
+                    var importNode = externalImports_4[_c];
                     var externalModuleName = getExternalModuleNameText(importNode);
                     var importAliasName = getLocalNameForExternalImport(importNode);
                     if (includeNonAmdDependencies && importAliasName) {
@@ -30322,7 +30734,7 @@ var ts;
             function emitSourceFileNode(node) {
                 writeLine();
                 emitShebang();
-                emitDetachedComments(node);
+                emitDetachedCommentsAndUpdateCommentsInfo(node);
                 if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
                     var emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[1];
                     emitModule(node);
@@ -30345,7 +30757,7 @@ var ts;
             }
             function emitNodeConsideringCommentsOption(node, emitNodeConsideringSourcemap) {
                 if (node) {
-                    if (node.flags & 2) {
+                    if (node.flags & 4) {
                         return emitCommentsOnNotEmittedNode(node);
                     }
                     if (isSpecializedCommentHandling(node)) {
@@ -30578,10 +30990,6 @@ var ts;
                 }
                 return leadingComments;
             }
-            function isPinnedComments(comment) {
-                return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 &&
-                    currentSourceFile.text.charCodeAt(comment.pos + 2) === 33;
-            }
             function isTripleSlashComment(comment) {
                 if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 47 &&
                     comment.pos + 2 < comment.end &&
@@ -30662,44 +31070,14 @@ var ts;
                 ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, { pos: pos, end: pos }, leadingComments);
                 ts.emitComments(currentSourceFile, writer, leadingComments, true, newLine, writeComment);
             }
-            function emitDetachedComments(node) {
-                var leadingComments;
-                if (compilerOptions.removeComments) {
-                    if (node.pos === 0) {
-                        leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComments);
+            function emitDetachedCommentsAndUpdateCommentsInfo(node) {
+                var currentDetachedCommentInfo = ts.emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, compilerOptions.removeComments);
+                if (currentDetachedCommentInfo) {
+                    if (detachedCommentsInfo) {
+                        detachedCommentsInfo.push(currentDetachedCommentInfo);
                     }
-                }
-                else {
-                    leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                }
-                if (leadingComments) {
-                    var detachedComments = [];
-                    var lastComment;
-                    ts.forEach(leadingComments, function (comment) {
-                        if (lastComment) {
-                            var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, lastComment.end);
-                            var commentLine = ts.getLineOfLocalPosition(currentSourceFile, comment.pos);
-                            if (commentLine >= lastCommentLine + 2) {
-                                return detachedComments;
-                            }
-                        }
-                        detachedComments.push(comment);
-                        lastComment = comment;
-                    });
-                    if (detachedComments.length) {
-                        var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
-                        var nodeLine = ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
-                        if (nodeLine >= lastCommentLine + 2) {
-                            ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
-                            ts.emitComments(currentSourceFile, writer, detachedComments, true, newLine, writeComment);
-                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
-                            if (detachedCommentsInfo) {
-                                detachedCommentsInfo.push(currentDetachedCommentInfo);
-                            }
-                            else {
-                                detachedCommentsInfo = [currentDetachedCommentInfo];
-                            }
-                        }
+                    else {
+                        detachedCommentsInfo = [currentDetachedCommentInfo];
                     }
                 }
             }
@@ -31002,7 +31380,7 @@ var ts;
         var resolveModuleNamesWorker = host.resolveModuleNames
             ? (function (moduleNames, containingFile) { return host.resolveModuleNames(moduleNames, containingFile); })
             : (function (moduleNames, containingFile) { return ts.map(moduleNames, function (moduleName) { return resolveModuleName(moduleName, containingFile, options, host).resolvedModule; }); });
-        var filesByName = ts.createFileMap(getCanonicalFileName);
+        var filesByName = ts.createFileMap();
         var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createFileMap(function (fileName) { return fileName.toLowerCase(); }) : undefined;
         if (oldProgram) {
             var oldOptions = oldProgram.getCompilerOptions();
@@ -31050,8 +31428,8 @@ var ts;
             if (!classifiableNames) {
                 getTypeChecker();
                 classifiableNames = {};
-                for (var _i = 0; _i < files.length; _i++) {
-                    var sourceFile = files[_i];
+                for (var _i = 0, files_3 = files; _i < files_3.length; _i++) {
+                    var sourceFile = files_3[_i];
                     ts.copyMap(sourceFile.classifiableNames, classifiableNames);
                 }
             }
@@ -31067,7 +31445,7 @@ var ts;
                 return false;
             }
             var newSourceFiles = [];
-            var normalizedAbsoluteFileNames = [];
+            var filePaths = [];
             var modifiedSourceFiles = [];
             for (var _i = 0, _a = oldProgram.getSourceFiles(); _i < _a.length; _i++) {
                 var oldSourceFile = _a[_i];
@@ -31075,8 +31453,8 @@ var ts;
                 if (!newSourceFile) {
                     return false;
                 }
-                var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);
-                normalizedAbsoluteFileNames.push(normalizedAbsolutePath);
+                newSourceFile.path = oldSourceFile.path;
+                filePaths.push(newSourceFile.path);
                 if (oldSourceFile !== newSourceFile) {
                     if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
                         return false;
@@ -31090,7 +31468,7 @@ var ts;
                     }
                     if (resolveModuleNamesWorker) {
                         var moduleNames = ts.map(newSourceFile.imports, function (name) { return name.text; });
-                        var resolutions = resolveModuleNamesWorker(moduleNames, normalizedAbsolutePath);
+                        var resolutions = resolveModuleNamesWorker(moduleNames, ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));
                         for (var i = 0; i < moduleNames.length; ++i) {
                             var newResolution = resolutions[i];
                             var oldResolution = ts.getResolvedModule(oldSourceFile, moduleNames[i]);
@@ -31113,12 +31491,12 @@ var ts;
                 newSourceFiles.push(newSourceFile);
             }
             for (var i = 0, len = newSourceFiles.length; i < len; ++i) {
-                filesByName.set(normalizedAbsoluteFileNames[i], newSourceFiles[i]);
+                filesByName.set(filePaths[i], newSourceFiles[i]);
             }
             files = newSourceFiles;
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
-            for (var _b = 0; _b < modifiedSourceFiles.length; _b++) {
-                var modifiedFile = modifiedSourceFiles[_b];
+            for (var _b = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _b < modifiedSourceFiles_1.length; _b++) {
+                var modifiedFile = modifiedSourceFiles_1[_b];
                 fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);
             }
             oldProgram.structureIsReused = true;
@@ -31157,7 +31535,7 @@ var ts;
             return emitResult;
         }
         function getSourceFile(fileName) {
-            return filesByName.get(ts.getNormalizedAbsolutePath(fileName, currentDirectory));
+            return filesByName.get(ts.toPath(fileName, currentDirectory, getCanonicalFileName));
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) {
             if (sourceFile) {
@@ -31266,7 +31644,7 @@ var ts;
                         }
                         break;
                     case 218:
-                        if (node.name.kind === 9 && (node.flags & 2 || ts.isDeclarationFile(file))) {
+                        if (node.name.kind === 9 && (node.flags & 4 || ts.isDeclarationFile(file))) {
                             ts.forEachChild(node.body, function (node) {
                                 collect(node, false);
                             });
@@ -31283,7 +31661,7 @@ var ts;
                     diagnostic = ts.Diagnostics.File_0_has_unsupported_extension_The_only_supported_extensions_are_1;
                     diagnosticArgument = [fileName, "'" + ts.supportedExtensions.join("', '") + "'"];
                 }
-                else if (!findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd)) {
+                else if (!findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd)) {
                     diagnostic = ts.Diagnostics.File_0_not_found;
                     diagnosticArgument = [fileName];
                 }
@@ -31293,13 +31671,13 @@ var ts;
                 }
             }
             else {
-                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd);
+                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd);
                 if (!nonTsFile) {
                     if (options.allowNonTsExtensions) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         diagnosticArgument = [fileName];
                     }
-                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.getNormalizedAbsolutePath(fileName + extension, currentDirectory), isDefaultLib, refFile, refPos, refEnd); })) {
+                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.toPath(fileName + extension, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd); })) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         fileName += ".ts";
                         diagnosticArgument = [fileName];
@@ -31341,6 +31719,7 @@ var ts;
             });
             filesByName.set(normalizedAbsolutePath, file);
             if (file) {
+                file.path = normalizedAbsolutePath;
                 if (host.useCaseSensitiveFileNames()) {
                     var existingFile = filesByNameIgnoreCase.get(normalizedAbsolutePath);
                     if (existingFile) {
@@ -31385,11 +31764,7 @@ var ts;
                     var resolution = resolutions[i];
                     ts.setResolvedModule(file, moduleNames[i], resolution);
                     if (resolution && !options.noResolve) {
-                        var absoluteImportPath = ts.isRootedDiskPath(resolution.resolvedFileName)
-                            ? resolution.resolvedFileName
-                            : ts.getNormalizedAbsolutePath(resolution.resolvedFileName, currentDirectory);
-                        var relativePath = ts.getRelativePathToDirectoryOrUrl(currentDirectory, absoluteImportPath, currentDirectory, getCanonicalFileName, false);
-                        var importedFile = findSourceFile(relativePath, absoluteImportPath, false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
+                        var importedFile = findSourceFile(resolution.resolvedFileName, ts.toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!ts.isExternalModule(importedFile)) {
                                 var start_2 = ts.getTokenPosOfNode(file.imports[i], file);
@@ -31440,8 +31815,8 @@ var ts;
             var allFilesBelongToPath = true;
             if (sourceFiles) {
                 var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) {
+                    var sourceFile = sourceFiles_1[_i];
                     if (!ts.isDeclarationFile(sourceFile)) {
                         var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
                         if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
@@ -31557,7 +31932,7 @@ var ts;
     var BreakpointResolver;
     (function (BreakpointResolver) {
         function spanInSourceFileAtLocation(sourceFile, position) {
-            if (sourceFile.flags & 8192) {
+            if (sourceFile.flags & 4096) {
                 return undefined;
             }
             var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position);
@@ -31732,7 +32107,7 @@ var ts;
                         : isDeclarationOfForStatement
                             ? variableDeclaration.parent.parent.initializer.declarations
                             : undefined;
-                    if (variableDeclaration.initializer || (variableDeclaration.flags & 1)) {
+                    if (variableDeclaration.initializer || (variableDeclaration.flags & 2)) {
                         if (declarations && declarations[0] === variableDeclaration) {
                             if (isParentVariableStatement) {
                                 return textSpan(variableDeclaration.parent, variableDeclaration);
@@ -31753,7 +32128,7 @@ var ts;
                 }
                 function canHaveSpanInParameterDeclaration(parameter) {
                     return !!parameter.initializer || parameter.dotDotDotToken !== undefined ||
-                        !!(parameter.flags & 16) || !!(parameter.flags & 32);
+                        !!(parameter.flags & 8) || !!(parameter.flags & 16);
                 }
                 function spanInParameterDeclaration(parameter) {
                     if (canHaveSpanInParameterDeclaration(parameter)) {
@@ -31771,7 +32146,7 @@ var ts;
                     }
                 }
                 function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) {
-                    return !!(functionDeclaration.flags & 1) ||
+                    return !!(functionDeclaration.flags & 2) ||
                         (functionDeclaration.parent.kind === 214 && functionDeclaration.kind !== 144);
                 }
                 function spanInFunctionDeclaration(functionDeclaration) {
@@ -31853,7 +32228,6 @@ var ts;
                             }
                         case 244:
                             return spanInNode(ts.lastOrUndefined(node.parent.statements));
-                            ;
                         case 220:
                             var caseBlock = node.parent;
                             var lastClause = ts.lastOrUndefined(caseBlock.clauses);
@@ -31888,7 +32262,6 @@ var ts;
                         default:
                             return spanInNode(node.parent);
                     }
-                    return spanInNode(node.parent);
                 }
                 function spanInColonToken(node) {
                     if (ts.isFunctionLike(node.parent) || node.parent.kind === 245) {
@@ -31949,8 +32322,8 @@ var ts;
                     var lastSingleLineCommentEnd = -1;
                     var isFirstSingleLineComment = true;
                     var singleLineCommentCount = 0;
-                    for (var _i = 0; _i < comments.length; _i++) {
-                        var currentComment = comments[_i];
+                    for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) {
+                        var currentComment = comments_2[_i];
                         if (currentComment.kind === 2) {
                             if (isFirstSingleLineComment) {
                                 firstSingleLineCommentStart = currentComment.pos;
@@ -32071,6 +32444,7 @@ var ts;
         function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) {
             var patternMatcher = ts.createPatternMatcher(searchValue);
             var rawItems = [];
+            var baseSensitivity = { sensitivity: "base" };
             ts.forEach(program.getSourceFiles(), function (sourceFile) {
                 cancellationToken.throwIfCancellationRequested();
                 var nameToDeclarations = sourceFile.getNamedDeclarations();
@@ -32081,8 +32455,8 @@ var ts;
                         if (!matches) {
                             continue;
                         }
-                        for (var _i = 0; _i < declarations.length; _i++) {
-                            var declaration = declarations[_i];
+                        for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                            var declaration = declarations_6[_i];
                             if (patternMatcher.patternContainsDots) {
                                 var containers = getContainers(declaration);
                                 if (!containers) {
@@ -32108,8 +32482,8 @@ var ts;
             return items;
             function allMatchesAreCaseSensitive(matches) {
                 ts.Debug.assert(matches.length > 0);
-                for (var _i = 0; _i < matches.length; _i++) {
-                    var match = matches[_i];
+                for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
+                    var match = matches_1[_i];
                     if (!match.isCaseSensitive) {
                         return false;
                     }
@@ -32177,8 +32551,8 @@ var ts;
             function bestMatchKind(matches) {
                 ts.Debug.assert(matches.length > 0);
                 var bestMatchKind = ts.PatternMatchKind.camelCase;
-                for (var _i = 0; _i < matches.length; _i++) {
-                    var match = matches[_i];
+                for (var _i = 0, matches_2 = matches; _i < matches_2.length; _i++) {
+                    var match = matches_2[_i];
                     var kind = match.kind;
                     if (kind < bestMatchKind) {
                         bestMatchKind = kind;
@@ -32186,7 +32560,6 @@ var ts;
                 }
                 return bestMatchKind;
             }
-            var baseSensitivity = { sensitivity: "base" };
             function compareNavigateToItems(i1, i2) {
                 return i1.matchKind - i2.matchKind ||
                     i1.name.localeCompare(i2.name, undefined, baseSensitivity) ||
@@ -32314,8 +32687,8 @@ var ts;
             }
             function addTopLevelNodes(nodes, topLevelNodes) {
                 nodes = sortNodes(nodes);
-                for (var _i = 0; _i < nodes.length; _i++) {
-                    var node = nodes[_i];
+                for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
+                    var node = nodes_4[_i];
                     switch (node.kind) {
                         case 214:
                         case 217:
@@ -32353,8 +32726,8 @@ var ts;
             function getItemsWorker(nodes, createItem) {
                 var items = [];
                 var keyToItem = {};
-                for (var _i = 0; _i < nodes.length; _i++) {
-                    var child = nodes[_i];
+                for (var _i = 0, nodes_5 = nodes; _i < nodes_5.length; _i++) {
+                    var child = nodes_5[_i];
                     var item = createItem(child);
                     if (item !== undefined) {
                         if (item.text.length > 0) {
@@ -32397,7 +32770,7 @@ var ts;
                         if (ts.isBindingPattern(node.name)) {
                             break;
                         }
-                        if ((node.flags & 2035) === 0) {
+                        if ((node.flags & 1022) === 0) {
                             return undefined;
                         }
                         return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement);
@@ -32661,8 +33034,8 @@ var ts;
             if (isLowercase) {
                 if (index > 0) {
                     var wordSpans = getWordSpans(candidate);
-                    for (var _i = 0; _i < wordSpans.length; _i++) {
-                        var span = wordSpans[_i];
+                    for (var _i = 0, wordSpans_1 = wordSpans; _i < wordSpans_1.length; _i++) {
+                        var span = wordSpans_1[_i];
                         if (partStartsWith(candidate, span, chunk.text, true)) {
                             return createPatternMatch(PatternMatchKind.substring, punctuationStripped, partStartsWith(candidate, span, chunk.text, false));
                         }
@@ -32714,8 +33087,8 @@ var ts;
             }
             var subWordTextChunks = segment.subWordTextChunks;
             var matches = undefined;
-            for (var _i = 0; _i < subWordTextChunks.length; _i++) {
-                var subWordTextChunk = subWordTextChunks[_i];
+            for (var _i = 0, subWordTextChunks_1 = subWordTextChunks; _i < subWordTextChunks_1.length; _i++) {
+                var subWordTextChunk = subWordTextChunks_1[_i];
                 var result = matchTextChunk(candidate, subWordTextChunk, true);
                 if (!result) {
                     return undefined;
@@ -33078,8 +33451,8 @@ var ts;
                     var nameToDeclarations = sourceFile_1.getNamedDeclarations();
                     var declarations = ts.getProperty(nameToDeclarations, name.text);
                     if (declarations) {
-                        for (var _b = 0; _b < declarations.length; _b++) {
-                            var declaration = declarations[_b];
+                        for (var _b = 0, declarations_7 = declarations; _b < declarations_7.length; _b++) {
+                            var declaration = declarations_7[_b];
                             var symbol = declaration.symbol;
                             if (symbol) {
                                 var type = typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
@@ -33155,8 +33528,8 @@ var ts;
             function getArgumentIndex(argumentsList, node) {
                 var argumentIndex = 0;
                 var listChildren = argumentsList.getChildren();
-                for (var _i = 0; _i < listChildren.length; _i++) {
-                    var child = listChildren[_i];
+                for (var _i = 0, listChildren_1 = listChildren; _i < listChildren_1.length; _i++) {
+                    var child = listChildren_1[_i];
                     if (child === node) {
                         break;
                     }
@@ -33598,8 +33971,8 @@ var ts;
                 return n;
             }
             var children = n.getChildren();
-            for (var _i = 0; _i < children.length; _i++) {
-                var child = children[_i];
+            for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+                var child = children_1[_i];
                 var shouldDiveInChildNode = (child.pos <= previousToken.pos && child.end > previousToken.end) ||
                     (child.pos === previousToken.end);
                 if (shouldDiveInChildNode && nodeHasTokens(child)) {
@@ -33722,17 +34095,17 @@ var ts;
     function getNodeModifiers(node) {
         var flags = ts.getCombinedNodeFlags(node);
         var result = [];
-        if (flags & 32)
-            result.push(ts.ScriptElementKindModifier.privateMemberModifier);
-        if (flags & 64)
-            result.push(ts.ScriptElementKindModifier.protectedMemberModifier);
         if (flags & 16)
+            result.push(ts.ScriptElementKindModifier.privateMemberModifier);
+        if (flags & 32)
+            result.push(ts.ScriptElementKindModifier.protectedMemberModifier);
+        if (flags & 8)
             result.push(ts.ScriptElementKindModifier.publicMemberModifier);
-        if (flags & 128)
+        if (flags & 64)
             result.push(ts.ScriptElementKindModifier.staticModifier);
-        if (flags & 256)
+        if (flags & 128)
             result.push(ts.ScriptElementKindModifier.abstractModifier);
-        if (flags & 1)
+        if (flags & 2)
             result.push(ts.ScriptElementKindModifier.exportedModifier);
         if (ts.isInAmbientContext(node))
             result.push(ts.ScriptElementKindModifier.ambientModifier);
@@ -35533,8 +35906,8 @@ var ts;
                         }
                     }
                     var inheritedIndentation = -1;
-                    for (var _i = 0; _i < nodes.length; _i++) {
-                        var child = nodes[_i];
+                    for (var _i = 0, nodes_6 = nodes; _i < nodes_6.length; _i++) {
+                        var child = nodes_6[_i];
                         inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, true);
                     }
                     if (listEndToken !== 0) {
@@ -35616,8 +35989,8 @@ var ts;
                 }
             }
             function processTrivia(trivia, parent, contextNode, dynamicIndentation) {
-                for (var _i = 0; _i < trivia.length; _i++) {
-                    var triviaItem = trivia[_i];
+                for (var _i = 0, trivia_1 = trivia; _i < trivia_1.length; _i++) {
+                    var triviaItem = trivia_1[_i];
                     if (ts.isComment(triviaItem.kind) && ts.rangeContainsRange(originalRange, triviaItem)) {
                         var triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos);
                         processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation);
@@ -36146,7 +36519,6 @@ var ts;
                                 return node;
                         }
                     }
-                    return node;
                 }
             }
             function deriveActualIndentationFromList(list, index, sourceFile, options) {
@@ -36374,17 +36746,17 @@ var ts;
             while (pos < end) {
                 var token = scanner.scan();
                 var textPos = scanner.getTextPos();
-                nodes.push(createNode(token, pos, textPos, 4096, this));
+                nodes.push(createNode(token, pos, textPos, 2048, this));
                 pos = textPos;
             }
             return pos;
         };
         NodeObject.prototype.createSyntaxList = function (nodes) {
-            var list = createNode(271, nodes.pos, nodes.end, 4096, this);
+            var list = createNode(271, nodes.pos, nodes.end, 2048, this);
             list._children = [];
             var pos = nodes.pos;
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_7 = nodes; _i < nodes_7.length; _i++) {
+                var node = nodes_7[_i];
                 if (pos < node.pos) {
                     pos = this.addSyntheticNodes(list._children, pos, node.pos);
                 }
@@ -36890,7 +37262,7 @@ var ts;
                         }
                         break;
                     case 138:
-                        if (!(node.flags & 112)) {
+                        if (!(node.flags & 56)) {
                             break;
                         }
                     case 211:
@@ -37089,18 +37461,20 @@ var ts;
     var HostCache = (function () {
         function HostCache(host, getCanonicalFileName) {
             this.host = host;
-            this.fileNameToEntry = ts.createFileMap(getCanonicalFileName);
+            this.getCanonicalFileName = getCanonicalFileName;
+            this.currentDirectory = host.getCurrentDirectory();
+            this.fileNameToEntry = ts.createFileMap();
             var rootFileNames = host.getScriptFileNames();
-            for (var _i = 0; _i < rootFileNames.length; _i++) {
-                var fileName = rootFileNames[_i];
-                this.createEntry(fileName);
+            for (var _i = 0, rootFileNames_1 = rootFileNames; _i < rootFileNames_1.length; _i++) {
+                var fileName = rootFileNames_1[_i];
+                this.createEntry(fileName, ts.toPath(fileName, this.currentDirectory, getCanonicalFileName));
             }
             this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
         }
         HostCache.prototype.compilationSettings = function () {
             return this._compilationSettings;
         };
-        HostCache.prototype.createEntry = function (fileName) {
+        HostCache.prototype.createEntry = function (fileName, path) {
             var entry;
             var scriptSnapshot = this.host.getScriptSnapshot(fileName);
             if (scriptSnapshot) {
@@ -37110,36 +37484,37 @@ var ts;
                     scriptSnapshot: scriptSnapshot
                 };
             }
-            this.fileNameToEntry.set(fileName, entry);
+            this.fileNameToEntry.set(path, entry);
             return entry;
         };
-        HostCache.prototype.getEntry = function (fileName) {
-            return this.fileNameToEntry.get(fileName);
+        HostCache.prototype.getEntry = function (path) {
+            return this.fileNameToEntry.get(path);
         };
-        HostCache.prototype.contains = function (fileName) {
-            return this.fileNameToEntry.contains(fileName);
+        HostCache.prototype.contains = function (path) {
+            return this.fileNameToEntry.contains(path);
         };
         HostCache.prototype.getOrCreateEntry = function (fileName) {
-            if (this.contains(fileName)) {
-                return this.getEntry(fileName);
+            var path = ts.toPath(fileName, this.currentDirectory, this.getCanonicalFileName);
+            if (this.contains(path)) {
+                return this.getEntry(path);
             }
-            return this.createEntry(fileName);
+            return this.createEntry(fileName, path);
         };
         HostCache.prototype.getRootFileNames = function () {
             var fileNames = [];
-            this.fileNameToEntry.forEachValue(function (value) {
+            this.fileNameToEntry.forEachValue(function (path, value) {
                 if (value) {
                     fileNames.push(value.hostFileName);
                 }
             });
             return fileNames;
         };
-        HostCache.prototype.getVersion = function (fileName) {
-            var file = this.getEntry(fileName);
+        HostCache.prototype.getVersion = function (path) {
+            var file = this.getEntry(path);
             return file && file.version;
         };
-        HostCache.prototype.getScriptSnapshot = function (fileName) {
-            var file = this.getEntry(fileName);
+        HostCache.prototype.getScriptSnapshot = function (path) {
+            var file = this.getEntry(path);
             return file && file.scriptSnapshot;
         };
         return HostCache;
@@ -37282,7 +37657,8 @@ var ts;
             : (function (fileName) { return fileName.toLowerCase(); });
     }
     ts.createGetCanonicalFileName = createGetCanonicalFileName;
-    function createDocumentRegistry(useCaseSensitiveFileNames) {
+    function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) {
+        if (currentDirectory === void 0) { currentDirectory = ""; }
         var buckets = {};
         var getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
         function getKeyFromCompilationSettings(settings) {
@@ -37292,7 +37668,7 @@ var ts;
             var key = getKeyFromCompilationSettings(settings);
             var bucket = ts.lookUp(buckets, key);
             if (!bucket && createIfMissing) {
-                buckets[key] = bucket = ts.createFileMap(getCanonicalFileName);
+                buckets[key] = bucket = ts.createFileMap();
             }
             return bucket;
         }
@@ -37300,14 +37676,13 @@ var ts;
             var bucketInfoArray = Object.keys(buckets).filter(function (name) { return name && name.charAt(0) === '_'; }).map(function (name) {
                 var entries = ts.lookUp(buckets, name);
                 var sourceFiles = [];
-                for (var i in entries) {
-                    var entry = entries.get(i);
+                entries.forEachValue(function (key, entry) {
                     sourceFiles.push({
-                        name: i,
+                        name: key,
                         refCount: entry.languageServiceRefCount,
                         references: entry.owners.slice(0)
                     });
-                }
+                });
                 sourceFiles.sort(function (x, y) { return y.refCount - x.refCount; });
                 return {
                     bucket: name,
@@ -37324,7 +37699,8 @@ var ts;
         }
         function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) {
             var bucket = getBucketForCompilationSettings(compilationSettings, true);
-            var entry = bucket.get(fileName);
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var entry = bucket.get(path);
             if (!entry) {
                 ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?");
                 var sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, false);
@@ -37333,7 +37709,7 @@ var ts;
                     languageServiceRefCount: 0,
                     owners: []
                 };
-                bucket.set(fileName, entry);
+                bucket.set(path, entry);
             }
             else {
                 if (entry.sourceFile.version !== version) {
@@ -37348,11 +37724,12 @@ var ts;
         function releaseDocument(fileName, compilationSettings) {
             var bucket = getBucketForCompilationSettings(compilationSettings, false);
             ts.Debug.assert(bucket !== undefined);
-            var entry = bucket.get(fileName);
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var entry = bucket.get(path);
             entry.languageServiceRefCount--;
             ts.Debug.assert(entry.languageServiceRefCount >= 0);
             if (entry.languageServiceRefCount === 0) {
-                bucket.remove(fileName);
+                bucket.remove(path);
             }
         }
         return {
@@ -37705,7 +38082,7 @@ var ts;
             case 144: return ScriptElementKind.constructorImplementationElement;
             case 137: return ScriptElementKind.typeParameterElement;
             case 247: return ScriptElementKind.variableElement;
-            case 138: return (node.flags & 112) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
+            case 138: return (node.flags & 56) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
             case 221:
             case 226:
             case 223:
@@ -37731,13 +38108,14 @@ var ts;
         return CancellationTokenObject;
     })();
     function createLanguageService(host, documentRegistry) {
-        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(); }
+        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()); }
         var syntaxTreeCache = new SyntaxTreeCache(host);
         var ruleProvider;
         var program;
         var lastProjectVersion;
         var useCaseSensitivefileNames = false;
         var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
+        var currentDirectory = host.getCurrentDirectory();
         if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) {
             ts.localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages();
         }
@@ -37748,8 +38126,7 @@ var ts;
         }
         var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames);
         function getValidSourceFile(fileName) {
-            fileName = ts.normalizeSlashes(fileName);
-            var sourceFile = program.getSourceFile(getCanonicalFileName(fileName));
+            var sourceFile = program.getSourceFile(fileName);
             if (!sourceFile) {
                 throw new Error("Could not find file: '" + fileName + "'.");
             }
@@ -37791,7 +38168,7 @@ var ts;
                 getNewLine: function () { return ts.getNewLineOrDefaultFromHost(host); },
                 getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); },
                 writeFile: function (fileName, data, writeByteOrderMark) { },
-                getCurrentDirectory: function () { return host.getCurrentDirectory(); },
+                getCurrentDirectory: function () { return currentDirectory; },
                 fileExists: function (fileName) {
                     ts.Debug.assert(!host.resolveModuleNames);
                     return hostCache.getOrCreateEntry(fileName) !== undefined;
@@ -37807,11 +38184,10 @@ var ts;
             var newProgram = ts.createProgram(hostCache.getRootFileNames(), newSettings, compilerHost, program);
             if (program) {
                 var oldSourceFiles = program.getSourceFiles();
-                for (var _i = 0; _i < oldSourceFiles.length; _i++) {
-                    var oldSourceFile = oldSourceFiles[_i];
-                    var fileName = oldSourceFile.fileName;
-                    if (!newProgram.getSourceFile(fileName) || changesInCompilationSettingsAffectSyntax) {
-                        documentRegistry.releaseDocument(fileName, oldSettings);
+                for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) {
+                    var oldSourceFile = oldSourceFiles_1[_i];
+                    if (!newProgram.getSourceFile(oldSourceFile.fileName) || changesInCompilationSettingsAffectSyntax) {
+                        documentRegistry.releaseDocument(oldSourceFile.fileName, oldSettings);
                     }
                 }
             }
@@ -37834,7 +38210,8 @@ var ts;
                 return documentRegistry.acquireDocument(fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version);
             }
             function sourceFileUpToDate(sourceFile) {
-                return sourceFile && sourceFile.version === hostCache.getVersion(sourceFile.fileName);
+                var path = sourceFile.path || ts.toPath(sourceFile.fileName, currentDirectory, getCanonicalFileName);
+                return sourceFile && sourceFile.version === hostCache.getVersion(path);
             }
             function programUpToDate() {
                 if (!program) {
@@ -37844,8 +38221,8 @@ var ts;
                 if (program.getSourceFiles().length !== rootFileNames.length) {
                     return false;
                 }
-                for (var _i = 0; _i < rootFileNames.length; _i++) {
-                    var fileName = rootFileNames[_i];
+                for (var _i = 0, rootFileNames_2 = rootFileNames; _i < rootFileNames_2.length; _i++) {
+                    var fileName = rootFileNames_2[_i];
                     if (!sourceFileUpToDate(program.getSourceFile(fileName))) {
                         return false;
                     }
@@ -38007,8 +38384,8 @@ var ts;
             }
             function checkModifiers(modifiers) {
                 if (modifiers) {
-                    for (var _i = 0; _i < modifiers.length; _i++) {
-                        var modifier = modifiers[_i];
+                    for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
+                        var modifier = modifiers_1[_i];
                         switch (modifier.kind) {
                             case 112:
                             case 110:
@@ -38571,8 +38948,8 @@ var ts;
             }
             function filterNamedImportOrExportCompletionItems(exportsOfModule, namedImportsOrExports) {
                 var exisingImportsOrExports = {};
-                for (var _i = 0; _i < namedImportsOrExports.length; _i++) {
-                    var element = namedImportsOrExports[_i];
+                for (var _i = 0, namedImportsOrExports_1 = namedImportsOrExports; _i < namedImportsOrExports_1.length; _i++) {
+                    var element = namedImportsOrExports_1[_i];
                     if (element.getStart() <= position && position <= element.getEnd()) {
                         continue;
                     }
@@ -38589,8 +38966,8 @@ var ts;
                     return contextualMemberSymbols;
                 }
                 var existingMemberNames = {};
-                for (var _i = 0; _i < existingMembers.length; _i++) {
-                    var m = existingMembers[_i];
+                for (var _i = 0, existingMembers_1 = existingMembers; _i < existingMembers_1.length; _i++) {
+                    var m = existingMembers_1[_i];
                     if (m.kind !== 245 &&
                         m.kind !== 246 &&
                         m.kind !== 163) {
@@ -38612,8 +38989,8 @@ var ts;
             }
             function filterJsxAttributes(symbols, attributes) {
                 var seenNames = {};
-                for (var _i = 0; _i < attributes.length; _i++) {
-                    var attr = attributes[_i];
+                for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
+                    var attr = attributes_1[_i];
                     if (attr.getStart() <= position && position <= attr.getEnd()) {
                         continue;
                     }
@@ -38701,8 +39078,8 @@ var ts;
                 var entries = [];
                 if (symbols) {
                     var nameToSymbol = {};
-                    for (var _i = 0; _i < symbols.length; _i++) {
-                        var symbol = symbols[_i];
+                    for (var _i = 0, symbols_3 = symbols; _i < symbols_3.length; _i++) {
+                        var symbol = symbols_3[_i];
                         var entry = createCompletionEntry(symbol, location);
                         if (entry) {
                             var id = ts.escapeIdentifier(entry.name);
@@ -39385,8 +39762,8 @@ var ts;
                     }
                     var fileNameToDocumentHighlights = {};
                     var result = [];
-                    for (var _i = 0; _i < referencedSymbols.length; _i++) {
-                        var referencedSymbol = referencedSymbols[_i];
+                    for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) {
+                        var referencedSymbol = referencedSymbols_1[_i];
                         for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
                             var referenceEntry = _b[_a];
                             var fileName_1 = referenceEntry.fileName;
@@ -39522,7 +39899,6 @@ var ts;
                             ts.forEachChild(node, aggregate);
                         }
                     }
-                    ;
                 }
                 function getThrowStatementOwner(throwStatement) {
                     var child = throwStatement;
@@ -39553,7 +39929,6 @@ var ts;
                             ts.forEachChild(node, aggregate);
                         }
                     }
-                    ;
                 }
                 function ownsBreakOrContinueStatement(owner, statement) {
                     var actualOwner = getBreakOrContinueOwner(statement);
@@ -39617,7 +39992,7 @@ var ts;
                     switch (container.kind) {
                         case 219:
                         case 248:
-                            if (modifierFlag & 256) {
+                            if (modifierFlag & 128) {
                                 nodes = declaration.members.concat(declaration);
                             }
                             else {
@@ -39630,7 +40005,7 @@ var ts;
                         case 214:
                         case 186:
                             nodes = container.members;
-                            if (modifierFlag & 112) {
+                            if (modifierFlag & 56) {
                                 var constructor = ts.forEach(container.members, function (member) {
                                     return member.kind === 144 && member;
                                 });
@@ -39638,7 +40013,7 @@ var ts;
                                     nodes = nodes.concat(constructor.parameters);
                                 }
                             }
-                            else if (modifierFlag & 256) {
+                            else if (modifierFlag & 128) {
                                 nodes = nodes.concat(container);
                             }
                             break;
@@ -39654,19 +40029,19 @@ var ts;
                     function getFlagFromModifier(modifier) {
                         switch (modifier) {
                             case 112:
-                                return 16;
+                                return 8;
                             case 110:
-                                return 32;
+                                return 16;
                             case 111:
-                                return 64;
+                                return 32;
                             case 113:
-                                return 128;
+                                return 64;
                             case 82:
-                                return 1;
-                            case 122:
                                 return 2;
+                            case 122:
+                                return 4;
                             case 115:
-                                return 256;
+                                return 128;
                             default:
                                 ts.Debug.fail();
                         }
@@ -39851,8 +40226,8 @@ var ts;
                     return undefined;
                 }
                 var result = [];
-                for (var _i = 0; _i < documentHighlights.length; _i++) {
-                    var entry = documentHighlights[_i];
+                for (var _i = 0, documentHighlights_1 = documentHighlights; _i < documentHighlights_1.length; _i++) {
+                    var entry = documentHighlights_1[_i];
                     for (var _a = 0, _b = entry.highlightSpans; _a < _b.length; _a++) {
                         var highlightSpan = _b[_a];
                         result.push({
@@ -39870,8 +40245,8 @@ var ts;
                 return undefined;
             }
             var referenceEntries = [];
-            for (var _i = 0; _i < referenceSymbols.length; _i++) {
-                var referenceSymbol = referenceSymbols[_i];
+            for (var _i = 0, referenceSymbols_1 = referenceSymbols; _i < referenceSymbols_1.length; _i++) {
+                var referenceSymbol = referenceSymbols_1[_i];
                 ts.addRange(referenceEntries, referenceSymbol.references);
             }
             return referenceEntries;
@@ -39939,8 +40314,8 @@ var ts;
             }
             else {
                 var internedName = getInternedName(symbol, node, declarations);
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) {
+                    var sourceFile = sourceFiles_2[_i];
                     cancellationToken.throwIfCancellationRequested();
                     var nameTable = getNameTable(sourceFile);
                     if (ts.lookUp(nameTable, internedName)) {
@@ -39985,7 +40360,7 @@ var ts;
                     return valueDeclaration;
                 }
                 if (symbol.flags & (4 | 8192)) {
-                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32) ? d : undefined; });
+                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 16) ? d : undefined; });
                     if (privateDeclaration) {
                         return ts.getAncestor(privateDeclaration, 214);
                     }
@@ -39999,8 +40374,8 @@ var ts;
                 var scope = undefined;
                 var declarations = symbol.getDeclarations();
                 if (declarations) {
-                    for (var _i = 0; _i < declarations.length; _i++) {
-                        var declaration = declarations[_i];
+                    for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
+                        var declaration = declarations_8[_i];
                         var container = getContainerNode(declaration);
                         if (!container) {
                             return undefined;
@@ -40153,7 +40528,7 @@ var ts;
                 if (!searchSpaceNode) {
                     return undefined;
                 }
-                var staticFlag = 128;
+                var staticFlag = 64;
                 switch (searchSpaceNode.kind) {
                     case 141:
                     case 140:
@@ -40178,7 +40553,7 @@ var ts;
                         return;
                     }
                     var container = ts.getSuperContainer(node, false);
-                    if (container && (128 & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
+                    if (container && (64 & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
                         references.push(getReferenceEntryFromNode(node));
                     }
                 });
@@ -40187,7 +40562,7 @@ var ts;
             }
             function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles) {
                 var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, false);
-                var staticFlag = 128;
+                var staticFlag = 64;
                 switch (searchSpaceNode.kind) {
                     case 143:
                     case 142:
@@ -40259,7 +40634,7 @@ var ts;
                                 break;
                             case 186:
                             case 214:
-                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128) === staticFlag) {
+                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 64) === staticFlag) {
                                     result.push(getReferenceEntryFromNode(node));
                                 }
                                 break;
@@ -40386,8 +40761,8 @@ var ts;
                     var lastIterationMeaning;
                     do {
                         lastIterationMeaning = meaning;
-                        for (var _i = 0; _i < declarations.length; _i++) {
-                            var declaration = declarations[_i];
+                        for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
+                            var declaration = declarations_9[_i];
                             var declarationMeaning = getMeaningFromDeclaration(declaration);
                             if (declarationMeaning & meaning) {
                                 meaning |= declarationMeaning;
@@ -40500,7 +40875,6 @@ var ts;
                     return 4 | 1;
             }
             return 1 | 2 | 4;
-            ts.Debug.fail("Unknown declaration type");
         }
         function isTypeReference(node) {
             if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) {
@@ -41007,8 +41381,8 @@ var ts;
                 if (matchKind) {
                     var parentElement = token.parent;
                     var childNodes = parentElement.getChildren(sourceFile);
-                    for (var _i = 0; _i < childNodes.length; _i++) {
-                        var current = childNodes[_i];
+                    for (var _i = 0, childNodes_1 = childNodes; _i < childNodes_1.length; _i++) {
+                        var current = childNodes_1[_i];
                         if (current.kind === matchKind) {
                             var range1 = ts.createTextSpan(token.getStart(sourceFile), token.getWidth(sourceFile));
                             var range2 = ts.createTextSpan(current.getStart(sourceFile), current.getWidth(sourceFile));
@@ -41224,8 +41598,8 @@ var ts;
                     if (declarations && declarations.length > 0) {
                         var defaultLibFileName = host.getDefaultLibFileName(host.getCompilationSettings());
                         if (defaultLibFileName) {
-                            for (var _i = 0; _i < declarations.length; _i++) {
-                                var current = declarations[_i];
+                            for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) {
+                                var current = declarations_10[_i];
                                 var sourceFile_2 = current.getSourceFile();
                                 var canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName));
                                 if (sourceFile_2 && getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName)) === getCanonicalFileName(ts.normalizePath(defaultLibFileName))) {
@@ -41962,8 +42336,8 @@ var ts;
                 if (this.logger.isVerbose()) {
                     this.logger.info(msg.type + ": " + json);
                 }
-                this.sendLineToClient('Content-Length: ' + (1 + this.byteLength(json, 'utf8')) +
-                    '\r\n\r\n' + json);
+                this.sendLineToClient("Content-Length: " + (1 + this.byteLength(json, "utf8")) +
+                    "\r\n\r\n" + json);
             };
             Session.prototype.event = function (info, eventName) {
                 var ev = {
@@ -42346,7 +42720,8 @@ var ts;
                                 };
                                 var preferredIndent = compilerService.languageService.getIndentationAtPosition(file, position, editorOptions);
                                 var hasIndent = 0;
-                                for (var i = 0, len = lineText.length; i < len; i++) {
+                                var i, len;
+                                for (i = 0, len = lineText.length; i < len; i++) {
                                     if (lineText.charAt(i) == " ") {
                                         hasIndent++;
                                     }
@@ -42553,7 +42928,7 @@ var ts;
                     if (navItem.kindModifiers && (navItem.kindModifiers != "")) {
                         bakedItem.kindModifiers = navItem.kindModifiers;
                     }
-                    if (navItem.matchKind != 'none') {
+                    if (navItem.matchKind !== "none") {
                         bakedItem.matchKind = navItem.matchKind;
                     }
                     if (navItem.containerName && (navItem.containerName.length > 0)) {
@@ -42592,8 +42967,8 @@ var ts;
                 var veryLowPriorityFiles = [];
                 var normalizedFileName = ts.normalizePath(fileName);
                 var project = this.projectService.getProjectForFile(normalizedFileName);
-                for (var _i = 0; _i < fileNamesInProject.length; _i++) {
-                    var fileNameInProject = fileNamesInProject[_i];
+                for (var _i = 0, fileNamesInProject_1 = fileNamesInProject; _i < fileNamesInProject_1.length; _i++) {
+                    var fileNameInProject = fileNamesInProject_1[_i];
                     if (this.getCanonicalFileName(fileNameInProject) == this.getCanonicalFileName(fileName))
                         highPriorityFiles.push(fileNameInProject);
                     else {
@@ -42641,12 +43016,14 @@ var ts;
                 }
             };
             Session.prototype.onMessage = function (message) {
+                var start;
                 if (this.logger.isVerbose()) {
                     this.logger.info("request: " + message);
-                    var start = this.hrtime();
+                    start = this.hrtime();
                 }
+                var request;
                 try {
-                    var request = JSON.parse(message);
+                    request = JSON.parse(message);
                     var _a = this.executeCommand(request), response = _a.response, responseRequired = _a.responseRequired;
                     if (this.logger.isVerbose()) {
                         var elapsed = this.hrtime(start);
@@ -42701,6 +43078,7 @@ var ts;
                 this.isOpen = isOpen;
                 this.children = [];
                 this.formatCodeOptions = ts.clone(CompilerService.defaultFormatCodeOptions);
+                this.path = ts.toPath(fileName, host.getCurrentDirectory(), ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames));
                 this.svc = ScriptVersionCache.fromString(host, content);
             }
             ScriptInfo.prototype.setFormatOptions = function (formatOptions) {
@@ -42742,23 +43120,23 @@ var ts;
                 var _this = this;
                 this.host = host;
                 this.project = project;
-                this.ls = null;
                 this.roots = [];
-                var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
-                this.resolvedModuleNames = ts.createFileMap(getCanonicalFileName);
-                this.filenameToScript = ts.createFileMap(getCanonicalFileName);
+                this.getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames);
+                this.resolvedModuleNames = ts.createFileMap();
+                this.filenameToScript = ts.createFileMap();
                 this.moduleResolutionHost = {
                     fileExists: function (fileName) { return _this.fileExists(fileName); },
                     readFile: function (fileName) { return _this.host.readFile(fileName); }
                 };
             }
             LSHost.prototype.resolveModuleNames = function (moduleNames, containingFile) {
-                var currentResolutionsInFile = this.resolvedModuleNames.get(containingFile);
+                var path = ts.toPath(containingFile, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+                var currentResolutionsInFile = this.resolvedModuleNames.get(path);
                 var newResolutions = {};
                 var resolvedModules = [];
                 var compilerOptions = this.getCompilationSettings();
-                for (var _i = 0; _i < moduleNames.length; _i++) {
-                    var moduleName = moduleNames[_i];
+                for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
+                    var moduleName = moduleNames_1[_i];
                     var resolution = ts.lookUp(newResolutions, moduleName);
                     if (!resolution) {
                         var existingResolution = currentResolutionsInFile && ts.lookUp(currentResolutionsInFile, moduleName);
@@ -42774,7 +43152,7 @@ var ts;
                     ts.Debug.assert(resolution !== undefined);
                     resolvedModules.push(resolution.resolvedModule);
                 }
-                this.resolvedModuleNames.set(containingFile, newResolutions);
+                this.resolvedModuleNames.set(path, newResolutions);
                 return resolvedModules;
                 function moduleResolutionIsValid(resolution) {
                     if (!resolution) {
@@ -42825,31 +43203,32 @@ var ts;
             };
             LSHost.prototype.removeReferencedFile = function (info) {
                 if (!info.isOpen) {
-                    this.filenameToScript.remove(info.fileName);
-                    this.resolvedModuleNames.remove(info.fileName);
+                    this.filenameToScript.remove(info.path);
+                    this.resolvedModuleNames.remove(info.path);
                 }
             };
             LSHost.prototype.getScriptInfo = function (filename) {
-                var scriptInfo = this.filenameToScript.get(filename);
+                var path = ts.toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+                var scriptInfo = this.filenameToScript.get(path);
                 if (!scriptInfo) {
                     scriptInfo = this.project.openReferencedFile(filename);
                     if (scriptInfo) {
-                        this.filenameToScript.set(scriptInfo.fileName, scriptInfo);
+                        this.filenameToScript.set(path, scriptInfo);
                     }
                 }
                 return scriptInfo;
             };
             LSHost.prototype.addRoot = function (info) {
-                if (!this.filenameToScript.contains(info.fileName)) {
-                    this.filenameToScript.set(info.fileName, info);
+                if (!this.filenameToScript.contains(info.path)) {
+                    this.filenameToScript.set(info.path, info);
                     this.roots.push(info);
                 }
             };
             LSHost.prototype.removeRoot = function (info) {
-                if (!this.filenameToScript.contains(info.fileName)) {
-                    this.filenameToScript.remove(info.fileName);
+                if (!this.filenameToScript.contains(info.path)) {
+                    this.filenameToScript.remove(info.path);
                     this.roots = copyListRemovingItem(info, this.roots);
-                    this.resolvedModuleNames.remove(info.fileName);
+                    this.resolvedModuleNames.remove(info.path);
                 }
             };
             LSHost.prototype.saveTo = function (filename, tmpfilename) {
@@ -42887,7 +43266,8 @@ var ts;
                 return this.host.directoryExists(path);
             };
             LSHost.prototype.lineToTextSpan = function (filename, line) {
-                var script = this.filenameToScript.get(filename);
+                var path = ts.toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+                var script = this.filenameToScript.get(path);
                 var index = script.snap().index;
                 var lineInfo = index.lineNumberToInfo(line + 1);
                 var len;
@@ -42901,13 +43281,15 @@ var ts;
                 return ts.createTextSpan(lineInfo.offset, len);
             };
             LSHost.prototype.lineOffsetToPosition = function (filename, line, offset) {
-                var script = this.filenameToScript.get(filename);
+                var path = ts.toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+                var script = this.filenameToScript.get(path);
                 var index = script.snap().index;
                 var lineInfo = index.lineNumberToInfo(line);
                 return (lineInfo.offset + offset - 1);
             };
             LSHost.prototype.positionToLineOffset = function (filename, position) {
-                var script = this.filenameToScript.get(filename);
+                var path = ts.toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+                var script = this.filenameToScript.get(path);
                 var index = script.snap().index;
                 var lineOffset = index.charOffsetToLineNumberAndPos(position);
                 return { line: lineOffset.line, offset: lineOffset.offset + 1 };
@@ -42921,22 +43303,22 @@ var ts;
                 return filename;
             }
             else {
-                var splitFilename = filename.split('/');
-                var splitDir = directory.split('/');
+                var splitFilename = filename.split("/");
+                var splitDir = directory.split("/");
                 var i = 0;
                 var dirTail = 0;
                 var sflen = splitFilename.length;
-                while ((i < sflen) && (splitFilename[i].charAt(0) == '.')) {
+                while ((i < sflen) && (splitFilename[i].charAt(0) == ".")) {
                     var dots = splitFilename[i];
-                    if (dots == '..') {
+                    if (dots == "..") {
                         dirTail++;
                     }
-                    else if (dots != '.') {
+                    else if (dots != ".") {
                         return undefined;
                     }
                     i++;
                 }
-                return splitDir.slice(0, splitDir.length - dirTail).concat(splitFilename.slice(i)).join('/');
+                return splitDir.slice(0, splitDir.length - dirTail).concat(splitFilename.slice(i)).join("/");
             }
         }
         var Project = (function () {
@@ -43111,8 +43493,8 @@ var ts;
                 var _a = this.configFileToProjectOptions(fileName), succeeded = _a.succeeded, projectOptions = _a.projectOptions, error = _a.error;
                 var rootFilesInTsconfig = projectOptions.files.map(function (f) { return _this.getCanonicalFileName(f); });
                 var openFileRoots = this.openFileRoots.map(function (s) { return _this.getCanonicalFileName(s.fileName); });
-                for (var _i = 0; _i < openFileRoots.length; _i++) {
-                    var openFileRoot = openFileRoots[_i];
+                for (var _i = 0, openFileRoots_1 = openFileRoots; _i < openFileRoots_1.length; _i++) {
+                    var openFileRoot = openFileRoots_1[_i];
                     if (rootFilesInTsconfig.indexOf(openFileRoot) >= 0) {
                         this.reloadProjects();
                         return;
@@ -43236,8 +43618,8 @@ var ts;
                     this.inferredProjects = copyListRemovingItem(project, this.inferredProjects);
                 }
                 var fileNames = project.getFileNames();
-                for (var _b = 0; _b < fileNames.length; _b++) {
-                    var fileName = fileNames[_b];
+                for (var _b = 0, fileNames_1 = fileNames; _b < fileNames_1.length; _b++) {
+                    var fileName = fileNames_1[_b];
                     var info = this.getScriptInfo(fileName);
                     if (info.defaultProject == project) {
                         info.defaultProject = undefined;
@@ -43591,10 +43973,11 @@ var ts;
                 }
                 else {
                     var parsedCommandLine = ts.parseJsonConfigFileContent(rawConfig.config, this.host, dirPath);
+                    ts.Debug.assert(!!parsedCommandLine.fileNames);
                     if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) {
                         return { succeeded: false, error: { errorMsg: "tsconfig option errors" } };
                     }
-                    else if (parsedCommandLine.fileNames == null) {
+                    else if (parsedCommandLine.fileNames.length === 0) {
                         return { succeeded: false, error: { errorMsg: "no files found" } };
                     }
                     else {
@@ -43646,15 +44029,15 @@ var ts;
                         var newFileNames = projectOptions.files;
                         var fileNamesToRemove = oldFileNames.filter(function (f) { return newFileNames.indexOf(f) < 0; });
                         var fileNamesToAdd = newFileNames.filter(function (f) { return oldFileNames.indexOf(f) < 0; });
-                        for (var _i = 0; _i < fileNamesToRemove.length; _i++) {
-                            var fileName = fileNamesToRemove[_i];
+                        for (var _i = 0, fileNamesToRemove_1 = fileNamesToRemove; _i < fileNamesToRemove_1.length; _i++) {
+                            var fileName = fileNamesToRemove_1[_i];
                             var info = this.getScriptInfo(fileName);
                             if (info) {
                                 project.removeRoot(info);
                             }
                         }
-                        for (var _b = 0; _b < fileNamesToAdd.length; _b++) {
-                            var fileName = fileNamesToAdd[_b];
+                        for (var _b = 0, fileNamesToAdd_1 = fileNamesToAdd; _b < fileNamesToAdd_1.length; _b++) {
+                            var fileName = fileNamesToAdd_1[_b];
                             var info = this.getScriptInfo(fileName);
                             if (!info) {
                                 info = this.openFile(fileName, false);
@@ -43714,7 +44097,7 @@ var ts;
             CompilerService.defaultFormatCodeOptions = {
                 IndentSize: 4,
                 TabSize: 4,
-                NewLineCharacter: ts.sys ? ts.sys.newLine : '\n',
+                NewLineCharacter: ts.sys ? ts.sys.newLine : "\n",
                 ConvertTabsToSpaces: true,
                 IndentStyle: ts.IndentStyle.Smart,
                 InsertSpaceAfterCommaDelimiter: true,
@@ -43804,7 +44187,7 @@ var ts;
                     if (len > 1) {
                         var insertedNodes = new Array(len - 1);
                         var startNode = leafNode;
-                        for (var i = 1, len = lines.length; i < len; i++) {
+                        for (var i = 1, len_1 = lines.length; i < len_1; i++) {
                             insertedNodes[i - 1] = new LineLeaf(lines[i]);
                         }
                         var pathIndex = this.startPath.length - 2;
@@ -44172,8 +44555,9 @@ var ts;
                     }
                 }
                 else {
+                    var checkText;
                     if (this.checkEdits) {
-                        var checkText = editFlat(this.getText(0, this.root.charCount()), pos, deleteLength, newText);
+                        checkText = editFlat(this.getText(0, this.root.charCount()), pos, deleteLength, newText);
                     }
                     var walker = new EditWalker();
                     if (pos >= this.root.charCount()) {
@@ -44399,7 +44783,9 @@ var ts;
             LineNode.prototype.childFromLineNumber = function (lineNumber, charOffset) {
                 var child;
                 var relativeLineNumber = lineNumber;
-                for (var i = 0, len = this.children.length; i < len; i++) {
+                var i;
+                var len;
+                for (i = 0, len = this.children.length; i < len; i++) {
                     child = this.children[i];
                     var childLineCount = child.lineCount();
                     if (childLineCount >= relativeLineNumber) {
@@ -44419,7 +44805,9 @@ var ts;
             };
             LineNode.prototype.childFromCharOffset = function (lineNumber, charOffset) {
                 var child;
-                for (var i = 0, len = this.children.length; i < len; i++) {
+                var i;
+                var len;
+                for (i = 0, len = this.children.length; i < len; i++) {
                     child = this.children[i];
                     if (child.charCount() > charOffset) {
                         break;
@@ -44501,7 +44889,7 @@ var ts;
                                 splitNode = splitNodes[splitNodeIndex];
                             }
                         }
-                        for (i = splitNodes.length - 1; i >= 0; i--) {
+                        for (var i = splitNodes.length - 1; i >= 0; i--) {
                             if (splitNodes[i].children.length === 0) {
                                 splitNodes.length--;
                             }
@@ -44511,7 +44899,7 @@ var ts;
                         splitNodes[splitNodes.length] = shiftNode;
                     }
                     this.updateCounts();
-                    for (i = 0; i < splitNodeCount; i++) {
+                    for (var i = 0; i < splitNodeCount; i++) {
                         splitNodes[i].updateCounts();
                     }
                     return splitNodes;
@@ -44561,10 +44949,10 @@ var ts;
 (function (ts) {
     var server;
     (function (server) {
-        var nodeproto = require('_debugger');
-        var readline = require('readline');
-        var path = require('path');
-        var fs = require('fs');
+        var nodeproto = require("_debugger");
+        var readline = require("readline");
+        var path = require("path");
+        var fs = require("fs");
         var rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout,
@@ -44644,11 +45032,11 @@ var ts;
             };
             IOSession.prototype.listen = function () {
                 var _this = this;
-                rl.on('line', function (input) {
+                rl.on("line", function (input) {
                     var message = input.trim();
                     _this.onMessage(message);
                 });
-                rl.on('close', function () {
+                rl.on("close", function () {
                     _this.exit();
                 });
             };
@@ -44656,7 +45044,7 @@ var ts;
         })(server.Session);
         function parseLoggingEnvironmentString(logEnvStr) {
             var logEnv = {};
-            var args = logEnvStr.split(' ');
+            var args = logEnvStr.split(" ");
             for (var i = 0, len = args.length; i < (len - 1); i += 2) {
                 var option = args[i];
                 var value = args[i + 1];
@@ -44711,7 +45099,7 @@ var ts;
         }
         ts.sys.write = function (s) { return writeMessage(s); };
         var ioSession = new IOSession(ts.sys, logger);
-        process.on('uncaughtException', function (err) {
+        process.on("uncaughtException", function (err) {
             ioSession.logError(err, "unknown");
         });
         ioSession.listen();
@@ -44794,7 +45182,6 @@ var ts;
             var settingsJson = this.shimHost.getCompilationSettings();
             if (settingsJson == null || settingsJson == "") {
                 throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
-                return null;
             }
             return JSON.parse(settingsJson);
         };
diff --git a/lib/typescript.d.ts b/lib/typescript.d.ts
index d94e55eb48f..972ebfa472d 100644
--- a/lib/typescript.d.ts
+++ b/lib/typescript.d.ts
@@ -17,19 +17,22 @@ declare namespace ts {
     interface Map<T> {
         [index: string]: T;
     }
+    type Path = string & {
+        __pathBrand: any;
+    };
     interface FileMap<T> {
-        get(fileName: string): T;
-        set(fileName: string, value: T): void;
-        contains(fileName: string): boolean;
-        remove(fileName: string): void;
-        forEachValue(f: (v: T) => void): void;
+        get(fileName: Path): T;
+        set(fileName: Path, value: T): void;
+        contains(fileName: Path): boolean;
+        remove(fileName: Path): void;
+        forEachValue(f: (key: Path, v: T) => void): void;
         clear(): void;
     }
     interface TextRange {
         pos: number;
         end: number;
     }
-    const enum SyntaxKind {
+    enum SyntaxKind {
         Unknown = 0,
         EndOfFileToken = 1,
         SingleLineCommentTrivia = 2,
@@ -327,31 +330,34 @@ declare namespace ts {
         LastBinaryOperator = 68,
         FirstNode = 135,
     }
-    const enum NodeFlags {
+    enum NodeFlags {
         None = 0,
-        Export = 1,
-        Ambient = 2,
-        Public = 16,
-        Private = 32,
-        Protected = 64,
-        Static = 128,
-        Abstract = 256,
-        Async = 512,
-        Default = 1024,
-        MultiLine = 2048,
-        Synthetic = 4096,
-        DeclarationFile = 8192,
-        Let = 16384,
-        Const = 32768,
-        OctalLiteral = 65536,
-        Namespace = 131072,
-        ExportContext = 262144,
-        ContainsThis = 524288,
-        Modifier = 2035,
-        AccessibilityModifier = 112,
-        BlockScoped = 49152,
+        Export = 2,
+        Ambient = 4,
+        Public = 8,
+        Private = 16,
+        Protected = 32,
+        Static = 64,
+        Abstract = 128,
+        Async = 256,
+        Default = 512,
+        MultiLine = 1024,
+        Synthetic = 2048,
+        DeclarationFile = 4096,
+        Let = 8192,
+        Const = 16384,
+        OctalLiteral = 32768,
+        Namespace = 65536,
+        ExportContext = 131072,
+        ContainsThis = 262144,
+        HasImplicitReturn = 524288,
+        HasExplicitReturn = 1048576,
+        Modifier = 1022,
+        AccessibilityModifier = 56,
+        BlockScoped = 24576,
+        ReachabilityCheckFlags = 1572864,
     }
-    const enum JsxFlags {
+    enum JsxFlags {
         None = 0,
         IntrinsicNamedElement = 1,
         IntrinsicIndexedElement = 2,
@@ -931,6 +937,7 @@ declare namespace ts {
         statements: NodeArray<Statement>;
         endOfFileToken: Node;
         fileName: string;
+        path: Path;
         text: string;
         amdDependencies: {
             path: string;
@@ -1093,7 +1100,7 @@ declare namespace ts {
         trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
         reportInaccessibleThisError(): void;
     }
-    const enum TypeFormatFlags {
+    enum TypeFormatFlags {
         None = 0,
         WriteArrayAsGenericType = 1,
         UseTypeOfFunction = 2,
@@ -1104,7 +1111,7 @@ declare namespace ts {
         InElementType = 64,
         UseFullyQualifiedType = 128,
     }
-    const enum SymbolFormatFlags {
+    enum SymbolFormatFlags {
         None = 0,
         WriteTypeParametersOrArguments = 1,
         UseOnlyExternalAliasing = 2,
@@ -1114,7 +1121,7 @@ declare namespace ts {
         parameterIndex: number;
         type: Type;
     }
-    const enum SymbolFlags {
+    enum SymbolFlags {
         None = 0,
         FunctionScopedVariable = 1,
         BlockScopedVariable = 2,
@@ -1191,7 +1198,7 @@ declare namespace ts {
     interface SymbolTable {
         [index: string]: Symbol;
     }
-    const enum TypeFlags {
+    enum TypeFlags {
         Any = 1,
         String = 2,
         Number = 4,
@@ -1262,7 +1269,7 @@ declare namespace ts {
     interface TypeParameter extends Type {
         constraint: Type;
     }
-    const enum SignatureKind {
+    enum SignatureKind {
         Call = 0,
         Construct = 1,
     }
@@ -1272,7 +1279,7 @@ declare namespace ts {
         parameters: Symbol[];
         typePredicate?: TypePredicate;
     }
-    const enum IndexKind {
+    enum IndexKind {
         String = 0,
         Number = 1,
     }
@@ -1307,7 +1314,7 @@ declare namespace ts {
         Error = 1,
         Message = 2,
     }
-    const enum ModuleResolutionKind {
+    enum ModuleResolutionKind {
         Classic = 1,
         NodeJs = 2,
     }
@@ -1352,10 +1359,14 @@ declare namespace ts {
         experimentalDecorators?: boolean;
         emitDecoratorMetadata?: boolean;
         moduleResolution?: ModuleResolutionKind;
+        allowUnusedLabels?: boolean;
+        allowUnreachableCode?: boolean;
+        noImplicitReturns?: boolean;
+        noFallthroughCasesInSwitch?: boolean;
         forceConsistentCasingInFileNames?: boolean;
         [option: string]: string | number | boolean;
     }
-    const enum ModuleKind {
+    enum ModuleKind {
         None = 0,
         CommonJS = 1,
         AMD = 2,
@@ -1364,12 +1375,12 @@ declare namespace ts {
         ES6 = 5,
         ES2015 = 5,
     }
-    const enum JsxEmit {
+    enum JsxEmit {
         None = 0,
         Preserve = 1,
         React = 2,
     }
-    const enum NewLineKind {
+    enum NewLineKind {
         CarriageReturnLineFeed = 0,
         LineFeed = 1,
     }
@@ -1377,14 +1388,14 @@ declare namespace ts {
         line: number;
         character: number;
     }
-    const enum ScriptTarget {
+    enum ScriptTarget {
         ES3 = 0,
         ES5 = 1,
         ES6 = 2,
         ES2015 = 2,
         Latest = 2,
     }
-    const enum LanguageVariant {
+    enum LanguageVariant {
         Standard = 0,
         JSX = 1,
     }
@@ -1938,7 +1949,7 @@ declare namespace ts {
         outputFiles: OutputFile[];
         emitSkipped: boolean;
     }
-    const enum OutputFileType {
+    enum OutputFileType {
         JavaScript = 0,
         SourceMap = 1,
         Declaration = 2,
@@ -1948,7 +1959,7 @@ declare namespace ts {
         writeByteOrderMark: boolean;
         text: string;
     }
-    const enum EndOfLineState {
+    enum EndOfLineState {
         None = 0,
         InMultiLineCommentTrivia = 1,
         InSingleQuoteStringLiteral = 2,
@@ -2116,7 +2127,7 @@ declare namespace ts {
         static parameterName: string;
         static docCommentTagName: string;
     }
-    const enum ClassificationType {
+    enum ClassificationType {
         comment = 1,
         identifier = 2,
         keyword = 3,
@@ -2159,7 +2170,7 @@ declare namespace ts {
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
     function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string;
-    function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry;
+    function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;
     function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo;
     function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService;
     function createClassifier(): Classifier;
diff --git a/lib/typescript.js b/lib/typescript.js
index 1e0c0edad05..8b0ef04f96e 100644
--- a/lib/typescript.js
+++ b/lib/typescript.js
@@ -350,27 +350,30 @@ var ts;
     var SyntaxKind = ts.SyntaxKind;
     (function (NodeFlags) {
         NodeFlags[NodeFlags["None"] = 0] = "None";
-        NodeFlags[NodeFlags["Export"] = 1] = "Export";
-        NodeFlags[NodeFlags["Ambient"] = 2] = "Ambient";
-        NodeFlags[NodeFlags["Public"] = 16] = "Public";
-        NodeFlags[NodeFlags["Private"] = 32] = "Private";
-        NodeFlags[NodeFlags["Protected"] = 64] = "Protected";
-        NodeFlags[NodeFlags["Static"] = 128] = "Static";
-        NodeFlags[NodeFlags["Abstract"] = 256] = "Abstract";
-        NodeFlags[NodeFlags["Async"] = 512] = "Async";
-        NodeFlags[NodeFlags["Default"] = 1024] = "Default";
-        NodeFlags[NodeFlags["MultiLine"] = 2048] = "MultiLine";
-        NodeFlags[NodeFlags["Synthetic"] = 4096] = "Synthetic";
-        NodeFlags[NodeFlags["DeclarationFile"] = 8192] = "DeclarationFile";
-        NodeFlags[NodeFlags["Let"] = 16384] = "Let";
-        NodeFlags[NodeFlags["Const"] = 32768] = "Const";
-        NodeFlags[NodeFlags["OctalLiteral"] = 65536] = "OctalLiteral";
-        NodeFlags[NodeFlags["Namespace"] = 131072] = "Namespace";
-        NodeFlags[NodeFlags["ExportContext"] = 262144] = "ExportContext";
-        NodeFlags[NodeFlags["ContainsThis"] = 524288] = "ContainsThis";
-        NodeFlags[NodeFlags["Modifier"] = 2035] = "Modifier";
-        NodeFlags[NodeFlags["AccessibilityModifier"] = 112] = "AccessibilityModifier";
-        NodeFlags[NodeFlags["BlockScoped"] = 49152] = "BlockScoped";
+        NodeFlags[NodeFlags["Export"] = 2] = "Export";
+        NodeFlags[NodeFlags["Ambient"] = 4] = "Ambient";
+        NodeFlags[NodeFlags["Public"] = 8] = "Public";
+        NodeFlags[NodeFlags["Private"] = 16] = "Private";
+        NodeFlags[NodeFlags["Protected"] = 32] = "Protected";
+        NodeFlags[NodeFlags["Static"] = 64] = "Static";
+        NodeFlags[NodeFlags["Abstract"] = 128] = "Abstract";
+        NodeFlags[NodeFlags["Async"] = 256] = "Async";
+        NodeFlags[NodeFlags["Default"] = 512] = "Default";
+        NodeFlags[NodeFlags["MultiLine"] = 1024] = "MultiLine";
+        NodeFlags[NodeFlags["Synthetic"] = 2048] = "Synthetic";
+        NodeFlags[NodeFlags["DeclarationFile"] = 4096] = "DeclarationFile";
+        NodeFlags[NodeFlags["Let"] = 8192] = "Let";
+        NodeFlags[NodeFlags["Const"] = 16384] = "Const";
+        NodeFlags[NodeFlags["OctalLiteral"] = 32768] = "OctalLiteral";
+        NodeFlags[NodeFlags["Namespace"] = 65536] = "Namespace";
+        NodeFlags[NodeFlags["ExportContext"] = 131072] = "ExportContext";
+        NodeFlags[NodeFlags["ContainsThis"] = 262144] = "ContainsThis";
+        NodeFlags[NodeFlags["HasImplicitReturn"] = 524288] = "HasImplicitReturn";
+        NodeFlags[NodeFlags["HasExplicitReturn"] = 1048576] = "HasExplicitReturn";
+        NodeFlags[NodeFlags["Modifier"] = 1022] = "Modifier";
+        NodeFlags[NodeFlags["AccessibilityModifier"] = 56] = "AccessibilityModifier";
+        NodeFlags[NodeFlags["BlockScoped"] = 24576] = "BlockScoped";
+        NodeFlags[NodeFlags["ReachabilityCheckFlags"] = 1572864] = "ReachabilityCheckFlags";
     })(ts.NodeFlags || (ts.NodeFlags = {}));
     var NodeFlags = ts.NodeFlags;
     /* @internal */
@@ -690,6 +693,12 @@ var ts;
     })(ts.LanguageVariant || (ts.LanguageVariant = {}));
     var LanguageVariant = ts.LanguageVariant;
     /* @internal */
+    (function (DiagnosticStyle) {
+        DiagnosticStyle[DiagnosticStyle["Simple"] = 0] = "Simple";
+        DiagnosticStyle[DiagnosticStyle["Pretty"] = 1] = "Pretty";
+    })(ts.DiagnosticStyle || (ts.DiagnosticStyle = {}));
+    var DiagnosticStyle = ts.DiagnosticStyle;
+    /* @internal */
     (function (CharacterCodes) {
         CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
         CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
@@ -838,40 +847,50 @@ var ts;
         Ternary[Ternary["True"] = -1] = "True";
     })(ts.Ternary || (ts.Ternary = {}));
     var Ternary = ts.Ternary;
-    function createFileMap(getCanonicalFileName) {
+    function createFileMap(keyMapper) {
         var files = {};
         return {
             get: get,
             set: set,
             contains: contains,
             remove: remove,
-            clear: clear,
-            forEachValue: forEachValueInMap
+            forEachValue: forEachValueInMap,
+            clear: clear
         };
-        function set(fileName, value) {
-            files[normalizeKey(fileName)] = value;
-        }
-        function get(fileName) {
-            return files[normalizeKey(fileName)];
-        }
-        function contains(fileName) {
-            return hasProperty(files, normalizeKey(fileName));
-        }
-        function remove(fileName) {
-            var key = normalizeKey(fileName);
-            delete files[key];
-        }
         function forEachValueInMap(f) {
-            forEachValue(files, f);
+            for (var key in files) {
+                f(key, files[key]);
+            }
         }
-        function normalizeKey(key) {
-            return getCanonicalFileName(normalizeSlashes(key));
+        // path should already be well-formed so it does not need to be normalized
+        function get(path) {
+            return files[toKey(path)];
+        }
+        function set(path, value) {
+            files[toKey(path)] = value;
+        }
+        function contains(path) {
+            return hasProperty(files, toKey(path));
+        }
+        function remove(path) {
+            var key = toKey(path);
+            delete files[key];
         }
         function clear() {
             files = {};
         }
+        function toKey(path) {
+            return keyMapper ? keyMapper(path) : path;
+        }
     }
     ts.createFileMap = createFileMap;
+    function toPath(fileName, basePath, getCanonicalFileName) {
+        var nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return getCanonicalFileName(nonCanonicalizedPath);
+    }
+    ts.toPath = toPath;
     (function (Comparison) {
         Comparison[Comparison["LessThan"] = -1] = "LessThan";
         Comparison[Comparison["EqualTo"] = 0] = "EqualTo";
@@ -897,8 +916,8 @@ var ts;
     ts.forEach = forEach;
     function contains(array, value) {
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+                var v = array_1[_i];
                 if (v === value) {
                     return true;
                 }
@@ -921,8 +940,8 @@ var ts;
     function countWhere(array, predicate) {
         var count = 0;
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
+                var v = array_2[_i];
                 if (predicate(v)) {
                     count++;
                 }
@@ -935,8 +954,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
+                var item = array_3[_i];
                 if (f(item)) {
                     result.push(item);
                 }
@@ -949,8 +968,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
+                var v = array_4[_i];
                 result.push(f(v));
             }
         }
@@ -969,8 +988,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
+                var item = array_5[_i];
                 if (!contains(result, item)) {
                     result.push(item);
                 }
@@ -981,8 +1000,8 @@ var ts;
     ts.deduplicate = deduplicate;
     function sum(array, prop) {
         var result = 0;
-        for (var _i = 0; _i < array.length; _i++) {
-            var v = array[_i];
+        for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
+            var v = array_6[_i];
             result += v[prop];
         }
         return result;
@@ -990,8 +1009,8 @@ var ts;
     ts.sum = sum;
     function addRange(to, from) {
         if (to && from) {
-            for (var _i = 0; _i < from.length; _i++) {
-                var v = from[_i];
+            for (var _i = 0, from_1 = from; _i < from_1.length; _i++) {
+                var v = from_1[_i];
                 to.push(v);
             }
         }
@@ -1341,8 +1360,8 @@ var ts;
     function getNormalizedParts(normalizedSlashedPath, rootLength) {
         var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator);
         var normalized = [];
-        for (var _i = 0; _i < parts.length; _i++) {
-            var part = parts[_i];
+        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+            var part = parts_1[_i];
             if (part !== ".") {
                 if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
@@ -1521,8 +1540,8 @@ var ts;
         if (!fileName) {
             return false;
         }
-        for (var _i = 0; _i < ts.supportedExtensions.length; _i++) {
-            var extension = ts.supportedExtensions[_i];
+        for (var _i = 0, supportedExtensions_1 = ts.supportedExtensions; _i < supportedExtensions_1.length; _i++) {
+            var extension = supportedExtensions_1[_i];
             if (fileExtensionIs(fileName, extension)) {
                 return true;
             }
@@ -1532,8 +1551,8 @@ var ts;
     ts.isSupportedSourceFileName = isSupportedSourceFileName;
     var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     function removeFileExtension(path) {
-        for (var _i = 0; _i < extensionsToRemove.length; _i++) {
-            var ext = extensionsToRemove[_i];
+        for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
+            var ext = extensionsToRemove_1[_i];
             if (fileExtensionIs(path, ext)) {
                 return path.substr(0, path.length - ext.length);
             }
@@ -1614,8 +1633,8 @@ var ts;
     })(Debug = ts.Debug || (ts.Debug = {}));
     function copyListRemovingItem(item, list) {
         var copiedList = [];
-        for (var _i = 0; _i < list.length; _i++) {
-            var e = list[_i];
+        for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+            var e = list_1[_i];
             if (e !== item) {
                 copiedList.push(e);
             }
@@ -1709,16 +1728,16 @@ var ts;
                 function visitDirectory(path) {
                     var folder = fso.GetFolder(path || ".");
                     var files = getNames(folder.files);
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        var current = files_1[_i];
                         var name_1 = ts.combinePaths(path, current);
                         if ((!extension || ts.fileExtensionIs(name_1, extension)) && !ts.contains(exclude, getCanonicalPath(name_1))) {
                             result.push(name_1);
                         }
                     }
                     var subfolders = getNames(folder.subfolders);
-                    for (var _a = 0; _a < subfolders.length; _a++) {
-                        var current = subfolders[_a];
+                    for (var _a = 0, subfolders_1 = subfolders; _a < subfolders_1.length; _a++) {
+                        var current = subfolders_1[_a];
                         var name_2 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_2))) {
                             visitDirectory(name_2);
@@ -1769,6 +1788,7 @@ var ts;
             var _fs = require("fs");
             var _path = require("path");
             var _os = require("os");
+            var _tty = require("tty");
             // average async stat takes about 30 microseconds
             // set chunk size to do 30 files in < 1 millisecond
             function createWatchedFileSet(interval, chunkSize) {
@@ -1906,8 +1926,8 @@ var ts;
                 function visitDirectory(path) {
                     var files = _fs.readdirSync(path || ".").sort();
                     var directories = [];
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_2 = files; _i < files_2.length; _i++) {
+                        var current = files_2[_i];
                         var name_3 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_3))) {
                             var stat = _fs.statSync(name_3);
@@ -1921,8 +1941,8 @@ var ts;
                             }
                         }
                     }
-                    for (var _a = 0; _a < directories.length; _a++) {
-                        var current = directories[_a];
+                    for (var _a = 0, directories_1 = directories; _a < directories_1.length; _a++) {
+                        var current = directories_1[_a];
                         visitDirectory(current);
                     }
                 }
@@ -1932,15 +1952,7 @@ var ts;
                 newLine: _os.EOL,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 write: function (s) {
-                    var buffer = new Buffer(s, "utf8");
-                    var offset = 0;
-                    var toWrite = buffer.length;
-                    var written = 0;
-                    // 1 is a standard descriptor for stdout
-                    while ((written = _fs.writeSync(1, buffer, offset, toWrite)) < toWrite) {
-                        offset += written;
-                        toWrite -= written;
-                    }
+                    process.stdout.write(s);
                 },
                 readFile: readFile,
                 writeFile: writeFile,
@@ -2223,6 +2235,7 @@ var ts;
         await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: ts.DiagnosticCategory.Error, key: "await_expression_is_only_allowed_within_an_async_function_1308", message: "'await' expression is only allowed within an async function." },
         Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: ts.DiagnosticCategory.Error, key: "Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher_1311", message: "Async functions are only available when targeting ECMAScript 6 and higher." },
         can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: { code: 1312, category: ts.DiagnosticCategory.Error, key: "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", message: "'=' can only be used in an object literal property inside a destructuring assignment." },
+        The_body_of_an_if_statement_cannot_be_the_empty_statement: { code: 1313, category: ts.DiagnosticCategory.Error, key: "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", message: "The body of an 'if' statement cannot be the empty statement." },
         Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_2300", message: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.DiagnosticCategory.Error, key: "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", message: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: ts.DiagnosticCategory.Error, key: "Static_members_cannot_reference_class_type_parameters_2302", message: "Static members cannot reference class type parameters." },
@@ -2275,7 +2288,7 @@ var ts;
         Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: ts.DiagnosticCategory.Error, key: "Neither_type_0_nor_type_1_is_assignable_to_the_other_2352", message: "Neither type '{0}' nor type '{1}' is assignable to the other." },
         Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: ts.DiagnosticCategory.Error, key: "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", message: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
         No_best_common_type_exists_among_return_expressions: { code: 2354, category: ts.DiagnosticCategory.Error, key: "No_best_common_type_exists_among_return_expressions_2354", message: "No best common type exists among return expressions." },
-        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_th_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." },
+        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value." },
         An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: ts.DiagnosticCategory.Error, key: "An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type_2356", message: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
         The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: ts.DiagnosticCategory.Error, key: "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer_2357", message: "The operand of an increment or decrement operator must be a variable, property or indexer." },
         The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", message: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." },
@@ -2296,7 +2309,7 @@ var ts;
         Duplicate_number_index_signature: { code: 2375, category: ts.DiagnosticCategory.Error, key: "Duplicate_number_index_signature_2375", message: "Duplicate number index signature." },
         A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: ts.DiagnosticCategory.Error, key: "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", message: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." },
         Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: ts.DiagnosticCategory.Error, key: "Constructors_for_derived_classes_must_contain_a_super_call_2377", message: "Constructors for derived classes must contain a 'super' call." },
-        A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement_2378", message: "A 'get' accessor must return a value or consist of a single 'throw' statement." },
+        A_get_accessor_must_return_a_value: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_2378", message: "A 'get' accessor must return a value." },
         Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: ts.DiagnosticCategory.Error, key: "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", message: "Getter and setter accessors do not agree in visibility." },
         get_and_set_accessor_must_have_the_same_type: { code: 2380, category: ts.DiagnosticCategory.Error, key: "get_and_set_accessor_must_have_the_same_type_2380", message: "'get' and 'set' accessor must have the same type." },
         A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: ts.DiagnosticCategory.Error, key: "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", message: "A signature with an implementation cannot use a string literal type." },
@@ -2586,8 +2599,6 @@ var ts;
         NEWLINE: { code: 6061, category: ts.DiagnosticCategory.Message, key: "NEWLINE_6061", message: "NEWLINE" },
         Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: ts.DiagnosticCategory.Error, key: "Argument_for_newLine_option_must_be_CRLF_or_LF_6062", message: "Argument for '--newLine' option must be 'CRLF' or 'LF'." },
         Argument_for_moduleResolution_option_must_be_node_or_classic: { code: 6063, category: ts.DiagnosticCategory.Error, key: "Argument_for_moduleResolution_option_must_be_node_or_classic_6063", message: "Argument for '--moduleResolution' option must be 'node' or 'classic'." },
-        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
-        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Enables_experimental_support_for_ES7_decorators: { code: 6065, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_decorators_6065", message: "Enables experimental support for ES7 decorators." },
         Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", message: "Enables experimental support for emitting type metadata for decorators." },
         Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_async_functions_6068", message: "Enables experimental support for ES7 async functions." },
@@ -2595,7 +2606,14 @@ var ts;
         Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: ts.DiagnosticCategory.Message, key: "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", message: "Initializes a TypeScript project and creates a tsconfig.json file." },
         Successfully_created_a_tsconfig_json_file: { code: 6071, category: ts.DiagnosticCategory.Message, key: "Successfully_created_a_tsconfig_json_file_6071", message: "Successfully created a tsconfig.json file." },
         Suppress_excess_property_checks_for_object_literals: { code: 6072, category: ts.DiagnosticCategory.Message, key: "Suppress_excess_property_checks_for_object_literals_6072", message: "Suppress excess property checks for object literals." },
-        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6073", message: "Disallow inconsistently-cased references to the same file." },
+        Stylize_errors_and_messages_using_color_and_context_experimental: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Stylize_errors_and_messages_using_color_and_context_experimental_6073", message: "Stylize errors and messages using color and context. (experimental)" },
+        Do_not_report_errors_on_unused_labels: { code: 6074, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unused_labels_6074", message: "Do not report errors on unused labels." },
+        Report_error_when_not_all_code_paths_in_function_return_a_value: { code: 6075, category: ts.DiagnosticCategory.Message, key: "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", message: "Report error when not all code paths in function return a value." },
+        Report_errors_for_fallthrough_cases_in_switch_statement: { code: 6076, category: ts.DiagnosticCategory.Message, key: "Report_errors_for_fallthrough_cases_in_switch_statement_6076", message: "Report errors for fallthrough cases in switch statement." },
+        Do_not_report_errors_on_unreachable_code: { code: 6077, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unreachable_code_6077", message: "Do not report errors on unreachable code." },
+        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6078, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6078", message: "Disallow inconsistently-cased references to the same file." },
+        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
+        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Variable_0_implicitly_has_an_1_type: { code: 7005, category: ts.DiagnosticCategory.Error, key: "Variable_0_implicitly_has_an_1_type_7005", message: "Variable '{0}' implicitly has an '{1}' type." },
         Parameter_0_implicitly_has_an_1_type: { code: 7006, category: ts.DiagnosticCategory.Error, key: "Parameter_0_implicitly_has_an_1_type_7006", message: "Parameter '{0}' implicitly has an '{1}' type." },
         Member_0_implicitly_has_an_1_type: { code: 7008, category: ts.DiagnosticCategory.Error, key: "Member_0_implicitly_has_an_1_type_7008", message: "Member '{0}' implicitly has an '{1}' type." },
@@ -2613,6 +2631,10 @@ var ts;
         Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: ts.DiagnosticCategory.Error, key: "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", message: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
         Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: ts.DiagnosticCategory.Error, key: "Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_typ_7025", message: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
         JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: ts.DiagnosticCategory.Error, key: "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", message: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
+        Unreachable_code_detected: { code: 7027, category: ts.DiagnosticCategory.Error, key: "Unreachable_code_detected_7027", message: "Unreachable code detected." },
+        Unused_label: { code: 7028, category: ts.DiagnosticCategory.Error, key: "Unused_label_7028", message: "Unused label." },
+        Fallthrough_case_in_switch: { code: 7029, category: ts.DiagnosticCategory.Error, key: "Fallthrough_case_in_switch_7029", message: "Fallthrough case in switch." },
+        Not_all_code_paths_return_a_value: { code: 7030, category: ts.DiagnosticCategory.Error, key: "Not_all_code_paths_return_a_value_7030", message: "Not all code paths return a value." },
         You_cannot_rename_this_element: { code: 8000, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_this_element_8000", message: "You cannot rename this element." },
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", message: "You cannot rename elements that are defined in the standard TypeScript library." },
         import_can_only_be_used_in_a_ts_file: { code: 8002, category: ts.DiagnosticCategory.Error, key: "import_can_only_be_used_in_a_ts_file_8002", message: "'import ... =' can only be used in a .ts file." },
@@ -4166,6 +4188,20 @@ var ts;
         ModuleInstanceState[ModuleInstanceState["ConstEnumOnly"] = 2] = "ConstEnumOnly";
     })(ts.ModuleInstanceState || (ts.ModuleInstanceState = {}));
     var ModuleInstanceState = ts.ModuleInstanceState;
+    var Reachability;
+    (function (Reachability) {
+        Reachability[Reachability["Unintialized"] = 1] = "Unintialized";
+        Reachability[Reachability["Reachable"] = 2] = "Reachable";
+        Reachability[Reachability["Unreachable"] = 4] = "Unreachable";
+        Reachability[Reachability["ReportedUnreachable"] = 8] = "ReportedUnreachable";
+    })(Reachability || (Reachability = {}));
+    function or(state1, state2) {
+        return (state1 | state2) & 2 /* Reachable */
+            ? 2 /* Reachable */
+            : (state1 & state2) & 8 /* ReportedUnreachable */
+                ? 8 /* ReportedUnreachable */
+                : 4 /* Unreachable */;
+    }
     function getModuleInstanceState(node) {
         // A module is uninstantiated if it contains only
         // 1. interface declarations, type alias declarations
@@ -4175,7 +4211,7 @@ var ts;
         else if (ts.isConstEnumDeclaration(node)) {
             return 2 /* ConstEnumOnly */;
         }
-        else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) {
+        else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && !(node.flags & 2 /* Export */)) {
             return 0 /* NonInstantiated */;
         }
         else if (node.kind === 219 /* ModuleBlock */) {
@@ -4226,31 +4262,56 @@ var ts;
         //      Functions, Methods, Modules, Source-files.
         ContainerFlags[ContainerFlags["IsContainerWithLocals"] = 5] = "IsContainerWithLocals";
     })(ContainerFlags || (ContainerFlags = {}));
-    function bindSourceFile(file) {
+    var binder = createBinder();
+    function bindSourceFile(file, options) {
         var start = new Date().getTime();
-        bindSourceFileWorker(file);
+        binder(file, options);
         ts.bindTime += new Date().getTime() - start;
     }
     ts.bindSourceFile = bindSourceFile;
-    function bindSourceFileWorker(file) {
+    function createBinder() {
+        var file;
+        var options;
         var parent;
         var container;
         var blockScopeContainer;
         var lastContainer;
         var seenThisKeyword;
+        // state used by reachability checks
+        var hasExplicitReturn;
+        var currentReachabilityState;
+        var labelStack;
+        var labelIndexMap;
+        var implicitLabels;
         // If this file is an external module, then it is automatically in strict-mode according to
         // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
         // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
-        var inStrictMode = !!file.externalModuleIndicator;
+        var inStrictMode;
         var symbolCount = 0;
-        var Symbol = ts.objectAllocator.getSymbolConstructor();
-        var classifiableNames = {};
-        if (!file.locals) {
-            bind(file);
-            file.symbolCount = symbolCount;
-            file.classifiableNames = classifiableNames;
+        var Symbol;
+        var classifiableNames;
+        function bindSourceFile(f, opts) {
+            file = f;
+            options = opts;
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            Symbol = ts.objectAllocator.getSymbolConstructor();
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            hasExplicitReturn = false;
+            labelStack = undefined;
+            labelIndexMap = undefined;
+            implicitLabels = undefined;
         }
-        return;
+        return bindSourceFile;
         function createSymbol(flags, name) {
             symbolCount++;
             return new Symbol(flags, name);
@@ -4303,7 +4364,7 @@ var ts;
                     return node.isExportEquals ? "export=" : "default";
                 case 213 /* FunctionDeclaration */:
                 case 214 /* ClassDeclaration */:
-                    return node.flags & 1024 /* Default */ ? "default" : undefined;
+                    return node.flags & 512 /* Default */ ? "default" : undefined;
             }
         }
         function getDisplayName(node) {
@@ -4319,7 +4380,7 @@ var ts;
          */
         function declareSymbol(symbolTable, parent, node, includes, excludes) {
             ts.Debug.assert(!ts.hasDynamicName(node));
-            var isDefaultExport = node.flags & 1024 /* Default */;
+            var isDefaultExport = node.flags & 512 /* Default */;
             // The exported symbol for an export default function/class node is always named "default"
             var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
             var symbol;
@@ -4358,7 +4419,7 @@ var ts;
                         ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : ts.Diagnostics.Duplicate_identifier_0;
                     ts.forEach(symbol.declarations, function (declaration) {
-                        if (declaration.flags & 1024 /* Default */) {
+                        if (declaration.flags & 512 /* Default */) {
                             message = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
                         }
                     });
@@ -4377,7 +4438,7 @@ var ts;
             return symbol;
         }
         function declareModuleMember(node, symbolFlags, symbolExcludes) {
-            var hasExportModifier = ts.getCombinedNodeFlags(node) & 1 /* Export */;
+            var hasExportModifier = ts.getCombinedNodeFlags(node) & 2 /* Export */;
             if (symbolFlags & 8388608 /* Alias */) {
                 if (node.kind === 230 /* ExportSpecifier */ || (node.kind === 221 /* ImportEqualsDeclaration */ && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -4398,7 +4459,7 @@ var ts;
                 //   2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol,
                 //      but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way
                 //      when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.
-                if (hasExportModifier || container.flags & 262144 /* ExportContext */) {
+                if (hasExportModifier || container.flags & 131072 /* ExportContext */) {
                     var exportKind = (symbolFlags & 107455 /* Value */ ? 1048576 /* ExportValue */ : 0) |
                         (symbolFlags & 793056 /* Type */ ? 2097152 /* ExportType */ : 0) |
                         (symbolFlags & 1536 /* Namespace */ ? 4194304 /* ExportNamespace */ : 0);
@@ -4453,18 +4514,229 @@ var ts;
                 blockScopeContainer = node;
                 blockScopeContainer.locals = undefined;
             }
-            if (node.kind === 215 /* InterfaceDeclaration */) {
+            var savedReachabilityState;
+            var savedLabelStack;
+            var savedLabels;
+            var savedImplicitLabels;
+            var savedHasExplicitReturn;
+            var kind = node.kind;
+            var flags = node.flags;
+            // reset all reachability check related flags on node (for incremental scenarios)
+            flags &= ~1572864 /* ReachabilityCheckFlags */;
+            if (kind === 215 /* InterfaceDeclaration */) {
                 seenThisKeyword = false;
-                ts.forEachChild(node, bind);
-                node.flags = seenThisKeyword ? node.flags | 524288 /* ContainsThis */ : node.flags & ~524288 /* ContainsThis */;
             }
-            else {
-                ts.forEachChild(node, bind);
+            var saveState = kind === 248 /* SourceFile */ || kind === 219 /* ModuleBlock */ || ts.isFunctionLikeKind(kind);
+            if (saveState) {
+                savedReachabilityState = currentReachabilityState;
+                savedLabelStack = labelStack;
+                savedLabels = labelIndexMap;
+                savedImplicitLabels = implicitLabels;
+                savedHasExplicitReturn = hasExplicitReturn;
+                currentReachabilityState = 2 /* Reachable */;
+                hasExplicitReturn = false;
+                labelStack = labelIndexMap = implicitLabels = undefined;
+            }
+            bindReachableStatement(node);
+            if (currentReachabilityState === 2 /* Reachable */ && ts.isFunctionLikeKind(kind) && ts.nodeIsPresent(node.body)) {
+                flags |= 524288 /* HasImplicitReturn */;
+                if (hasExplicitReturn) {
+                    flags |= 1048576 /* HasExplicitReturn */;
+                }
+            }
+            if (kind === 215 /* InterfaceDeclaration */) {
+                flags = seenThisKeyword ? flags | 262144 /* ContainsThis */ : flags & ~262144 /* ContainsThis */;
+            }
+            node.flags = flags;
+            if (saveState) {
+                hasExplicitReturn = savedHasExplicitReturn;
+                currentReachabilityState = savedReachabilityState;
+                labelStack = savedLabelStack;
+                labelIndexMap = savedLabels;
+                implicitLabels = savedImplicitLabels;
             }
             container = saveContainer;
             parent = saveParent;
             blockScopeContainer = savedBlockScopeContainer;
         }
+        /**
+         * Returns true if node and its subnodes were successfully traversed.
+         * Returning false means that node was not examined and caller needs to dive into the node himself.
+         */
+        function bindReachableStatement(node) {
+            if (checkUnreachable(node)) {
+                ts.forEachChild(node, bind);
+                return;
+            }
+            switch (node.kind) {
+                case 198 /* WhileStatement */:
+                    bindWhileStatement(node);
+                    break;
+                case 197 /* DoStatement */:
+                    bindDoStatement(node);
+                    break;
+                case 199 /* ForStatement */:
+                    bindForStatement(node);
+                    break;
+                case 200 /* ForInStatement */:
+                case 201 /* ForOfStatement */:
+                    bindForInOrForOfStatement(node);
+                    break;
+                case 196 /* IfStatement */:
+                    bindIfStatement(node);
+                    break;
+                case 204 /* ReturnStatement */:
+                case 208 /* ThrowStatement */:
+                    bindReturnOrThrow(node);
+                    break;
+                case 203 /* BreakStatement */:
+                case 202 /* ContinueStatement */:
+                    bindBreakOrContinueStatement(node);
+                    break;
+                case 209 /* TryStatement */:
+                    bindTryStatement(node);
+                    break;
+                case 206 /* SwitchStatement */:
+                    bindSwitchStatement(node);
+                    break;
+                case 220 /* CaseBlock */:
+                    bindCaseBlock(node);
+                    break;
+                case 207 /* LabeledStatement */:
+                    bindLabeledStatement(node);
+                    break;
+                default:
+                    ts.forEachChild(node, bind);
+                    break;
+            }
+        }
+        function bindWhileStatement(n) {
+            var preWhileState = n.expression.kind === 84 /* FalseKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            var postWhileState = n.expression.kind === 99 /* TrueKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+            currentReachabilityState = preWhileState;
+            var postWhileLabel = pushImplicitLabel();
+            bind(n.statement);
+            popImplicitLabel(postWhileLabel, postWhileState);
+        }
+        function bindDoStatement(n) {
+            var preDoState = currentReachabilityState;
+            var postDoLabel = pushImplicitLabel();
+            bind(n.statement);
+            var postDoState = n.expression.kind === 99 /* TrueKeyword */ ? 4 /* Unreachable */ : preDoState;
+            popImplicitLabel(postDoLabel, postDoState);
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+        }
+        function bindForStatement(n) {
+            var preForState = currentReachabilityState;
+            var postForLabel = pushImplicitLabel();
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.condition);
+            bind(n.incrementor);
+            bind(n.statement);
+            // for statement is considered infinite when it condition is either omitted or is true keyword
+            // - for(..;;..)
+            // - for(..;true;..)
+            var isInfiniteLoop = (!n.condition || n.condition.kind === 99 /* TrueKeyword */);
+            var postForState = isInfiniteLoop ? 4 /* Unreachable */ : preForState;
+            popImplicitLabel(postForLabel, postForState);
+        }
+        function bindForInOrForOfStatement(n) {
+            var preStatementState = currentReachabilityState;
+            var postStatementLabel = pushImplicitLabel();
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.expression);
+            bind(n.statement);
+            popImplicitLabel(postStatementLabel, preStatementState);
+        }
+        function bindIfStatement(n) {
+            // denotes reachability state when entering 'thenStatement' part of the if statement: 
+            // i.e. if condition is false then thenStatement is unreachable
+            var ifTrueState = n.expression.kind === 84 /* FalseKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            // denotes reachability state when entering 'elseStatement':
+            // i.e. if condition is true then elseStatement is unreachable
+            var ifFalseState = n.expression.kind === 99 /* TrueKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            currentReachabilityState = ifTrueState;
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            bind(n.thenStatement);
+            if (n.elseStatement) {
+                var preElseState = currentReachabilityState;
+                currentReachabilityState = ifFalseState;
+                bind(n.elseStatement);
+                currentReachabilityState = or(currentReachabilityState, preElseState);
+            }
+            else {
+                currentReachabilityState = or(currentReachabilityState, ifFalseState);
+            }
+        }
+        function bindReturnOrThrow(n) {
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            if (n.kind === 204 /* ReturnStatement */) {
+                hasExplicitReturn = true;
+            }
+            currentReachabilityState = 4 /* Unreachable */;
+        }
+        function bindBreakOrContinueStatement(n) {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+            // for continue case touch label so it will be marked a used
+            var isValidJump = jumpToLabel(n.label, n.kind === 203 /* BreakStatement */ ? currentReachabilityState : 4 /* Unreachable */);
+            if (isValidJump) {
+                currentReachabilityState = 4 /* Unreachable */;
+            }
+        }
+        function bindTryStatement(n) {
+            // catch\finally blocks has the same reachability as try block
+            var preTryState = currentReachabilityState;
+            bind(n.tryBlock);
+            var postTryState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.catchClause);
+            var postCatchState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.finallyBlock);
+            // post catch/finally state is reachable if
+            // - post try state is reachable - control flow can fall out of try block
+            // - post catch state is reachable - control flow can fall out of catch block
+            currentReachabilityState = or(postTryState, postCatchState);
+        }
+        function bindSwitchStatement(n) {
+            var preSwitchState = currentReachabilityState;
+            var postSwitchLabel = pushImplicitLabel();
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            bind(n.caseBlock);
+            var hasDefault = ts.forEach(n.caseBlock.clauses, function (c) { return c.kind === 242 /* DefaultClause */; });
+            // post switch state is unreachable if switch is exaustive (has a default case ) and does not have fallthrough from the last case
+            var postSwitchState = hasDefault && currentReachabilityState !== 2 /* Reachable */ ? 4 /* Unreachable */ : preSwitchState;
+            popImplicitLabel(postSwitchLabel, postSwitchState);
+        }
+        function bindCaseBlock(n) {
+            var startState = currentReachabilityState;
+            for (var _i = 0, _a = n.clauses; _i < _a.length; _i++) {
+                var clause = _a[_i];
+                currentReachabilityState = startState;
+                bind(clause);
+                if (clause.statements.length && currentReachabilityState === 2 /* Reachable */ && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, ts.Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+        function bindLabeledStatement(n) {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+            var ok = pushNamedLabel(n.label);
+            bind(n.statement);
+            if (ok) {
+                popNamedLabel(n.label, currentReachabilityState);
+            }
+        }
         function getContainerFlags(node) {
             switch (node.kind) {
                 case 186 /* ClassExpression */:
@@ -4576,7 +4848,7 @@ var ts;
             }
         }
         function declareClassMember(node, symbolFlags, symbolExcludes) {
-            return node.flags & 128 /* Static */
+            return node.flags & 64 /* Static */
                 ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
                 : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
         }
@@ -4585,15 +4857,6 @@ var ts;
                 ? declareModuleMember(node, symbolFlags, symbolExcludes)
                 : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
         }
-        function isAmbientContext(node) {
-            while (node) {
-                if (node.flags & 2 /* Ambient */) {
-                    return true;
-                }
-                node = node.parent;
-            }
-            return false;
-        }
         function hasExportDeclarations(node) {
             var body = node.kind === 248 /* SourceFile */ ? node : node.body;
             if (body.kind === 248 /* SourceFile */ || body.kind === 219 /* ModuleBlock */) {
@@ -4609,11 +4872,11 @@ var ts;
         function setExportContextFlag(node) {
             // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular
             // declarations with export modifiers) is an export context in which declarations are implicitly exported.
-            if (isAmbientContext(node) && !hasExportDeclarations(node)) {
-                node.flags |= 262144 /* ExportContext */;
+            if (ts.isInAmbientContext(node) && !hasExportDeclarations(node)) {
+                node.flags |= 131072 /* ExportContext */;
             }
             else {
-                node.flags &= ~262144 /* ExportContext */;
+                node.flags &= ~131072 /* ExportContext */;
             }
         }
         function bindModuleDeclaration(node) {
@@ -4805,7 +5068,7 @@ var ts;
             }
         }
         function checkStrictModeNumericLiteral(node) {
-            if (inStrictMode && node.flags & 65536 /* OctalLiteral */) {
+            if (inStrictMode && node.flags & 32768 /* OctalLiteral */) {
                 file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
         }
@@ -4829,10 +5092,10 @@ var ts;
         function checkStrictModeWithStatement(node) {
             // Grammar checking for withStatement
             if (inStrictMode) {
-                grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
             }
         }
-        function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+        function errorOnFirstToken(node, message, arg0, arg1, arg2) {
             var span = ts.getSpanOfTokenAtPosition(file, node.pos);
             file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
         }
@@ -4840,6 +5103,9 @@ var ts;
             return "__" + ts.indexOf(node.parent.parameters, node);
         }
         function bind(node) {
+            if (!node) {
+                return;
+            }
             node.parent = parent;
             var savedInStrictMode = inStrictMode;
             if (!savedInStrictMode) {
@@ -4882,8 +5148,8 @@ var ts;
             }
         }
         function updateStrictModeStatementList(statements) {
-            for (var _i = 0; _i < statements.length; _i++) {
-                var statement = statements[_i];
+            for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+                var statement = statements_1[_i];
                 if (!ts.isPrologueDirective(statement)) {
                     return;
                 }
@@ -5105,7 +5371,7 @@ var ts;
             }
             // If this is a property-parameter, then also declare the property symbol into the
             // containing class.
-            if (node.flags & 112 /* AccessibilityModifier */ &&
+            if (node.flags & 56 /* AccessibilityModifier */ &&
                 node.parent.kind === 144 /* Constructor */ &&
                 ts.isClassLike(node.parent.parent)) {
                 var classDeclaration = node.parent.parent;
@@ -5117,6 +5383,112 @@ var ts;
                 ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
+        // reachability checks
+        function pushNamedLabel(name) {
+            initializeReachabilityStateIfNecessary();
+            if (ts.hasProperty(labelIndexMap, name.text)) {
+                return false;
+            }
+            labelIndexMap[name.text] = labelStack.push(1 /* Unintialized */) - 1;
+            return true;
+        }
+        function pushImplicitLabel() {
+            initializeReachabilityStateIfNecessary();
+            var index = labelStack.push(1 /* Unintialized */) - 1;
+            implicitLabels.push(index);
+            return index;
+        }
+        function popNamedLabel(label, outerState) {
+            var index = labelIndexMap[label.text];
+            ts.Debug.assert(index !== undefined);
+            ts.Debug.assert(labelStack.length == index + 1);
+            labelIndexMap[label.text] = undefined;
+            setCurrentStateAtLabel(labelStack.pop(), outerState, label);
+        }
+        function popImplicitLabel(implicitLabelIndex, outerState) {
+            if (labelStack.length !== implicitLabelIndex + 1) {
+                ts.Debug.assert(false, "Label stack: " + labelStack.length + ", index:" + implicitLabelIndex);
+            }
+            var i = implicitLabels.pop();
+            if (implicitLabelIndex !== i) {
+                ts.Debug.assert(false, "i: " + i + ", index: " + implicitLabelIndex);
+            }
+            setCurrentStateAtLabel(labelStack.pop(), outerState, /*name*/ undefined);
+        }
+        function setCurrentStateAtLabel(innerMergedState, outerState, label) {
+            if (innerMergedState === 1 /* Unintialized */) {
+                if (label && !options.allowUnusedLabels) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(label, ts.Diagnostics.Unused_label));
+                }
+                currentReachabilityState = outerState;
+            }
+            else {
+                currentReachabilityState = or(innerMergedState, outerState);
+            }
+        }
+        function jumpToLabel(label, outerState) {
+            initializeReachabilityStateIfNecessary();
+            var index = label ? labelIndexMap[label.text] : ts.lastOrUndefined(implicitLabels);
+            if (index === undefined) {
+                // reference to unknown label or
+                // break/continue used outside of loops
+                return false;
+            }
+            var stateAtLabel = labelStack[index];
+            labelStack[index] = stateAtLabel === 1 /* Unintialized */ ? outerState : or(stateAtLabel, outerState);
+            return true;
+        }
+        function checkUnreachable(node) {
+            switch (currentReachabilityState) {
+                case 4 /* Unreachable */:
+                    var reportError = 
+                    // report error on all statements
+                    ts.isStatement(node) ||
+                        // report error on class declarations
+                        node.kind === 214 /* ClassDeclaration */ ||
+                        // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+                        (node.kind === 218 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)) ||
+                        // report error on regular enums and const enums if preserveConstEnums is set
+                        (node.kind === 217 /* EnumDeclaration */ && (!ts.isConstEnumDeclaration(node) || options.preserveConstEnums));
+                    if (reportError) {
+                        currentReachabilityState = 8 /* ReportedUnreachable */;
+                        // unreachable code is reported if
+                        // - user has explicitly asked about it AND
+                        // - statement is in not ambient context (statements in ambient context is already an error 
+                        //   so we should not report extras) AND
+                        //   - node is not variable statement OR
+                        //   - node is block scoped variable statement OR
+                        //   - node is not block scoped variable statement and at least one variable declaration has initializer
+                        //   Rationale: we don't want to report errors on non-initialized var's since they are hoisted
+                        //   On the other side we do want to report errors on non-initialized 'lets' because of TDZ
+                        var reportUnreachableCode = !options.allowUnreachableCode &&
+                            !ts.isInAmbientContext(node) &&
+                            (node.kind !== 193 /* VariableStatement */ ||
+                                ts.getCombinedNodeFlags(node.declarationList) & 24576 /* BlockScoped */ ||
+                                ts.forEach(node.declarationList.declarations, function (d) { return d.initializer; }));
+                        if (reportUnreachableCode) {
+                            errorOnFirstToken(node, ts.Diagnostics.Unreachable_code_detected);
+                        }
+                    }
+                case 8 /* ReportedUnreachable */:
+                    return true;
+                default:
+                    return false;
+            }
+            function shouldReportErrorOnModuleDeclaration(node) {
+                var instanceState = getModuleInstanceState(node);
+                return instanceState === 1 /* Instantiated */ || (instanceState === 2 /* ConstEnumOnly */ && options.preserveConstEnums);
+            }
+        }
+        function initializeReachabilityStateIfNecessary() {
+            if (labelIndexMap) {
+                return;
+            }
+            currentReachabilityState = 2 /* Reachable */;
+            labelIndexMap = {};
+            labelStack = [];
+            implicitLabels = [];
+        }
     }
 })(ts || (ts = {}));
 /// <reference path="binder.ts" />
@@ -5127,8 +5499,8 @@ var ts;
     function getDeclarationOfKind(symbol, kind) {
         var declarations = symbol.declarations;
         if (declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) {
+                var declaration = declarations_1[_i];
                 if (declaration.kind === kind) {
                     return declaration;
                 }
@@ -5328,7 +5700,7 @@ var ts;
     }
     ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName;
     function isBlockOrCatchScoped(declaration) {
-        return (getCombinedNodeFlags(declaration) & 49152 /* BlockScoped */) !== 0 ||
+        return (getCombinedNodeFlags(declaration) & 24576 /* BlockScoped */) !== 0 ||
             isCatchClauseVariableDeclaration(declaration);
     }
     ts.isBlockOrCatchScoped = isBlockOrCatchScoped;
@@ -5441,7 +5813,7 @@ var ts;
     }
     ts.isExternalModule = isExternalModule;
     function isDeclarationFile(file) {
-        return (file.flags & 8192 /* DeclarationFile */) !== 0;
+        return (file.flags & 4096 /* DeclarationFile */) !== 0;
     }
     ts.isDeclarationFile = isDeclarationFile;
     function isConstEnumDeclaration(node) {
@@ -5478,11 +5850,11 @@ var ts;
     }
     ts.getCombinedNodeFlags = getCombinedNodeFlags;
     function isConst(node) {
-        return !!(getCombinedNodeFlags(node) & 32768 /* Const */);
+        return !!(getCombinedNodeFlags(node) & 16384 /* Const */);
     }
     ts.isConst = isConst;
     function isLet(node) {
-        return !!(getCombinedNodeFlags(node) & 16384 /* Let */);
+        return !!(getCombinedNodeFlags(node) & 8192 /* Let */);
     }
     ts.isLet = isLet;
     function isPrologueDirective(node) {
@@ -5683,27 +6055,28 @@ var ts;
     }
     ts.isClassLike = isClassLike;
     function isFunctionLike(node) {
-        if (node) {
-            switch (node.kind) {
-                case 144 /* Constructor */:
-                case 173 /* FunctionExpression */:
-                case 213 /* FunctionDeclaration */:
-                case 174 /* ArrowFunction */:
-                case 143 /* MethodDeclaration */:
-                case 142 /* MethodSignature */:
-                case 145 /* GetAccessor */:
-                case 146 /* SetAccessor */:
-                case 147 /* CallSignature */:
-                case 148 /* ConstructSignature */:
-                case 149 /* IndexSignature */:
-                case 152 /* FunctionType */:
-                case 153 /* ConstructorType */:
-                    return true;
-            }
-        }
-        return false;
+        return node && isFunctionLikeKind(node.kind);
     }
     ts.isFunctionLike = isFunctionLike;
+    function isFunctionLikeKind(kind) {
+        switch (kind) {
+            case 144 /* Constructor */:
+            case 173 /* FunctionExpression */:
+            case 213 /* FunctionDeclaration */:
+            case 174 /* ArrowFunction */:
+            case 143 /* MethodDeclaration */:
+            case 142 /* MethodSignature */:
+            case 145 /* GetAccessor */:
+            case 146 /* SetAccessor */:
+            case 147 /* CallSignature */:
+            case 148 /* ConstructSignature */:
+            case 149 /* IndexSignature */:
+            case 152 /* FunctionType */:
+            case 153 /* ConstructorType */:
+                return true;
+        }
+    }
+    ts.isFunctionLikeKind = isFunctionLikeKind;
     function introducesArgumentsExoticObject(node) {
         switch (node.kind) {
             case 143 /* MethodDeclaration */:
@@ -6206,9 +6579,18 @@ var ts;
         return !!node && (node.kind === 162 /* ArrayBindingPattern */ || node.kind === 161 /* ObjectBindingPattern */);
     }
     ts.isBindingPattern = isBindingPattern;
+    function isNodeDescendentOf(node, ancestor) {
+        while (node) {
+            if (node === ancestor)
+                return true;
+            node = node.parent;
+        }
+        return false;
+    }
+    ts.isNodeDescendentOf = isNodeDescendentOf;
     function isInAmbientContext(node) {
         while (node) {
-            if (node.flags & (2 /* Ambient */ | 8192 /* DeclarationFile */)) {
+            if (node.flags & (4 /* Ambient */ | 4096 /* DeclarationFile */)) {
                 return true;
             }
             node = node.parent;
@@ -6266,7 +6648,7 @@ var ts;
             case 207 /* LabeledStatement */:
             case 204 /* ReturnStatement */:
             case 206 /* SwitchStatement */:
-            case 98 /* ThrowKeyword */:
+            case 208 /* ThrowStatement */:
             case 209 /* TryStatement */:
             case 193 /* VariableStatement */:
             case 198 /* WhileStatement */:
@@ -6379,8 +6761,8 @@ var ts;
     ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes;
     function getHeritageClause(clauses, kind) {
         if (clauses) {
-            for (var _i = 0; _i < clauses.length; _i++) {
-                var clause = clauses[_i];
+            for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) {
+                var clause = clauses_1[_i];
                 if (clause.token === kind) {
                     return clause;
                 }
@@ -6392,7 +6774,6 @@ var ts;
     function tryResolveScriptReference(host, sourceFile, reference) {
         if (!host.getCompilerOptions().noResolve) {
             var referenceFileName = ts.isRootedDiskPath(reference.fileName) ? reference.fileName : ts.combinePaths(ts.getDirectoryPath(sourceFile.fileName), reference.fileName);
-            referenceFileName = ts.getNormalizedAbsolutePath(referenceFileName, host.getCurrentDirectory());
             return host.getSourceFile(referenceFileName);
         }
     }
@@ -6450,7 +6831,7 @@ var ts;
     }
     ts.isTrivia = isTrivia;
     function isAsyncFunctionLike(node) {
-        return isFunctionLike(node) && (node.flags & 512 /* Async */) !== 0 && !isAccessor(node);
+        return isFunctionLike(node) && (node.flags & 256 /* Async */) !== 0 && !isAccessor(node);
     }
     ts.isAsyncFunctionLike = isAsyncFunctionLike;
     /**
@@ -6837,7 +7218,7 @@ var ts;
         else {
             ts.forEach(declarations, function (member) {
                 if ((member.kind === 145 /* GetAccessor */ || member.kind === 146 /* SetAccessor */)
-                    && (member.flags & 128 /* Static */) === (accessor.flags & 128 /* Static */)) {
+                    && (member.flags & 64 /* Static */) === (accessor.flags & 64 /* Static */)) {
                     var memberName = getPropertyNameForPropertyNameNode(member.name);
                     var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
                     if (memberName === accessorName) {
@@ -6894,6 +7275,66 @@ var ts;
         });
     }
     ts.emitComments = emitComments;
+    /**
+     * Detached comment is a comment at the top of file or function body that is separated from
+     * the next statement by space.
+     */
+    function emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, removeComments) {
+        var leadingComments;
+        var currentDetachedCommentInfo;
+        if (removeComments) {
+            // removeComments is true, only reserve pinned comment at the top of file
+            // For example:
+            //      /*! Pinned Comment */
+            //
+            //      var x = 10;
+            if (node.pos === 0) {
+                leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComment);
+            }
+        }
+        else {
+            // removeComments is false, just get detached as normal and bypass the process to filter comment
+            leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
+        }
+        if (leadingComments) {
+            var detachedComments = [];
+            var lastComment;
+            for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) {
+                var comment = leadingComments_1[_i];
+                if (lastComment) {
+                    var lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end);
+                    var commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos);
+                    if (commentLine >= lastCommentLine + 2) {
+                        // There was a blank line between the last comment and this comment.  This
+                        // comment is not part of the copyright comments.  Return what we have so
+                        // far.
+                        break;
+                    }
+                }
+                detachedComments.push(comment);
+                lastComment = comment;
+            }
+            if (detachedComments.length) {
+                // All comments look like they could have been part of the copyright header.  Make
+                // sure there is at least one blank line between it and the node.  If not, it's not
+                // a copyright header.
+                var lastCommentLine = getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
+                var nodeLine = getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
+                if (nodeLine >= lastCommentLine + 2) {
+                    // Valid detachedComments
+                    emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
+                    emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
+                    currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
+                }
+            }
+        }
+        return currentDetachedCommentInfo;
+        function isPinnedComment(comment) {
+            return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
+                currentSourceFile.text.charCodeAt(comment.pos + 2) === 33 /* exclamation */;
+        }
+    }
+    ts.emitDetachedComments = emitDetachedComments;
     function writeCommentRange(currentSourceFile, writer, comment, newLine) {
         if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */) {
             var firstCommentLineAndCharacter = ts.getLineAndCharacterOfPosition(currentSourceFile, comment.pos);
@@ -6983,16 +7424,16 @@ var ts;
     ts.writeCommentRange = writeCommentRange;
     function modifierToFlag(token) {
         switch (token) {
-            case 113 /* StaticKeyword */: return 128 /* Static */;
-            case 112 /* PublicKeyword */: return 16 /* Public */;
-            case 111 /* ProtectedKeyword */: return 64 /* Protected */;
-            case 110 /* PrivateKeyword */: return 32 /* Private */;
-            case 115 /* AbstractKeyword */: return 256 /* Abstract */;
-            case 82 /* ExportKeyword */: return 1 /* Export */;
-            case 122 /* DeclareKeyword */: return 2 /* Ambient */;
-            case 74 /* ConstKeyword */: return 32768 /* Const */;
-            case 77 /* DefaultKeyword */: return 1024 /* Default */;
-            case 118 /* AsyncKeyword */: return 512 /* Async */;
+            case 113 /* StaticKeyword */: return 64 /* Static */;
+            case 112 /* PublicKeyword */: return 8 /* Public */;
+            case 111 /* ProtectedKeyword */: return 32 /* Protected */;
+            case 110 /* PrivateKeyword */: return 16 /* Private */;
+            case 115 /* AbstractKeyword */: return 128 /* Abstract */;
+            case 82 /* ExportKeyword */: return 2 /* Export */;
+            case 122 /* DeclareKeyword */: return 4 /* Ambient */;
+            case 74 /* ConstKeyword */: return 16384 /* Const */;
+            case 77 /* DefaultKeyword */: return 512 /* Default */;
+            case 118 /* AsyncKeyword */: return 256 /* Async */;
         }
         return 0;
     }
@@ -7073,7 +7514,7 @@ var ts;
     }
     ts.isEmptyObjectLiteralOrArrayLiteral = isEmptyObjectLiteralOrArrayLiteral;
     function getLocalSymbolForExportDefault(symbol) {
-        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 1024 /* Default */) ? symbol.valueDeclaration.localSymbol : undefined;
+        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 512 /* Default */) ? symbol.valueDeclaration.localSymbol : undefined;
     }
     ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault;
     function isJavaScript(fileName) {
@@ -7150,6 +7591,12 @@ var ts;
         return result;
     }
     ts.convertToBase64 = convertToBase64;
+    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+        return !ts.isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : ts.getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, /* isAbsolutePathAnUrl */ false);
+    }
+    ts.convertToRelativePath = convertToRelativePath;
     var carriageReturnLineFeed = "\r\n";
     var lineFeed = "\n";
     function getNewLineCharacter(options) {
@@ -7414,8 +7861,8 @@ var ts;
     }
     function visitEachNode(cbNode, nodes) {
         if (nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
                 var result = cbNode(node);
                 if (result) {
                     return result;
@@ -7982,8 +8429,8 @@ var ts;
         function addJSDocComment(node) {
             var comments = ts.getLeadingCommentRangesOfNode(node, sourceFile);
             if (comments) {
-                for (var _i = 0; _i < comments.length; _i++) {
-                    var comment = comments[_i];
+                for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+                    var comment = comments_1[_i];
                     var jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
                     if (jsDocComment) {
                         node.jsDocComment = jsDocComment;
@@ -8021,7 +8468,7 @@ var ts;
             sourceFile.bindDiagnostics = [];
             sourceFile.languageVersion = languageVersion;
             sourceFile.fileName = ts.normalizePath(fileName);
-            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 8192 /* DeclarationFile */ : 0;
+            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 4096 /* DeclarationFile */ : 0;
             sourceFile.languageVariant = ts.isTsx(sourceFile.fileName) ? 1 /* JSX */ : 0 /* Standard */;
             return sourceFile;
         }
@@ -9079,7 +9526,7 @@ var ts;
             if (node.kind === 8 /* NumericLiteral */
                 && sourceText.charCodeAt(tokenPos) === 48 /* _0 */
                 && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
-                node.flags |= 65536 /* OctalLiteral */;
+                node.flags |= 32768 /* OctalLiteral */;
             }
             return node;
         }
@@ -9832,7 +10279,7 @@ var ts;
                 // Didn't appear to actually be a parenthesized arrow function.  Just bail out.
                 return undefined;
             }
-            var isAsync = !!(arrowFunction.flags & 512 /* Async */);
+            var isAsync = !!(arrowFunction.flags & 256 /* Async */);
             // If we have an arrow, then try to parse the body. Even if not, try to parse if we
             // have an opening brace, just in case we're in an error state.
             var lastToken = token;
@@ -9959,7 +10406,7 @@ var ts;
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) {
             var node = createNode(174 /* ArrowFunction */);
             setModifiers(node, parseModifiersForArrowFunction());
-            var isAsync = !!(node.flags & 512 /* Async */);
+            var isAsync = !!(node.flags & 256 /* Async */);
             // Arrow functions are never generators.
             //
             // If we're speculatively parsing a signature for a parenthesized arrow function, then
@@ -10802,7 +11249,7 @@ var ts;
             var node = createNode(164 /* ArrayLiteralExpression */);
             parseExpected(19 /* OpenBracketToken */);
             if (scanner.hasPrecedingLineBreak())
-                node.flags |= 2048 /* MultiLine */;
+                node.flags |= 1024 /* MultiLine */;
             node.elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
             parseExpected(20 /* CloseBracketToken */);
             return finishNode(node);
@@ -10863,7 +11310,7 @@ var ts;
             var node = createNode(165 /* ObjectLiteralExpression */);
             parseExpected(15 /* OpenBraceToken */);
             if (scanner.hasPrecedingLineBreak()) {
-                node.flags |= 2048 /* MultiLine */;
+                node.flags |= 1024 /* MultiLine */;
             }
             node.properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimeter*/ true);
             parseExpected(16 /* CloseBraceToken */);
@@ -10884,7 +11331,7 @@ var ts;
             parseExpected(87 /* FunctionKeyword */);
             node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512 /* Async */);
+            var isAsync = !!(node.flags & 256 /* Async */);
             node.name =
                 isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
                     isGenerator ? doInYieldContext(parseOptionalIdentifier) :
@@ -11476,10 +11923,10 @@ var ts;
                 case 102 /* VarKeyword */:
                     break;
                 case 108 /* LetKeyword */:
-                    node.flags |= 16384 /* Let */;
+                    node.flags |= 8192 /* Let */;
                     break;
                 case 74 /* ConstKeyword */:
-                    node.flags |= 32768 /* Const */;
+                    node.flags |= 16384 /* Const */;
                     break;
                 default:
                     ts.Debug.fail();
@@ -11522,9 +11969,9 @@ var ts;
             setModifiers(node, modifiers);
             parseExpected(87 /* FunctionKeyword */);
             node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
-            node.name = node.flags & 1024 /* Default */ ? parseOptionalIdentifier() : parseIdentifier();
+            node.name = node.flags & 512 /* Default */ ? parseOptionalIdentifier() : parseIdentifier();
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512 /* Async */);
+            var isAsync = !!(node.flags & 256 /* Async */);
             fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
             node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
             return finishNode(node);
@@ -11546,7 +11993,7 @@ var ts;
             method.name = name;
             method.questionToken = questionToken;
             var isGenerator = !!asteriskToken;
-            var isAsync = !!(method.flags & 512 /* Async */);
+            var isAsync = !!(method.flags & 256 /* Async */);
             fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method);
             method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
             return finishNode(method);
@@ -11567,7 +12014,7 @@ var ts;
             //        AccessibilityModifier_opt  static_opt  PropertyName   TypeAnnotation_opt   Initialiser_opt[In, ?Yield];
             //
             // The checker may still error in the static case to explicitly disallow the yield expression.
-            property.initializer = modifiers && modifiers.flags & 128 /* Static */
+            property.initializer = modifiers && modifiers.flags & 64 /* Static */
                 ? allowInAnd(parseNonParameterInitializer)
                 : doOutsideOfContext(2 /* Yield */ | 1 /* DisallowIn */, parseNonParameterInitializer);
             parseSemicolon();
@@ -11900,13 +12347,13 @@ var ts;
             var node = createNode(218 /* ModuleDeclaration */, fullStart);
             // If we are parsing a dotted namespace name, we want to
             // propagate the 'Namespace' flag across the names if set.
-            var namespaceFlag = flags & 131072 /* Namespace */;
+            var namespaceFlag = flags & 65536 /* Namespace */;
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.flags |= flags;
             node.name = parseIdentifier();
             node.body = parseOptional(21 /* DotToken */)
-                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, 1 /* Export */ | namespaceFlag)
+                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, 2 /* Export */ | namespaceFlag)
                 : parseModuleBlock();
             return finishNode(node);
         }
@@ -11921,7 +12368,7 @@ var ts;
         function parseModuleDeclaration(fullStart, decorators, modifiers) {
             var flags = modifiers ? modifiers.flags : 0;
             if (parseOptional(126 /* NamespaceKeyword */)) {
-                flags |= 131072 /* Namespace */;
+                flags |= 65536 /* Namespace */;
             }
             else {
                 parseExpected(125 /* ModuleKeyword */);
@@ -12179,7 +12626,7 @@ var ts;
         }
         function setExternalModuleIndicator(sourceFile) {
             sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) {
-                return node.flags & 1 /* Export */
+                return node.flags & 2 /* Export */
                     || node.kind === 221 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 232 /* ExternalModuleReference */
                     || node.kind === 222 /* ImportDeclaration */
                     || node.kind === 227 /* ExportAssignment */
@@ -12868,8 +13315,8 @@ var ts;
                 array._children = undefined;
                 array.pos += delta;
                 array.end += delta;
-                for (var _i = 0; _i < array.length; _i++) {
-                    var node = array[_i];
+                for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
+                    var node = array_7[_i];
                     visitNode(node);
                 }
             }
@@ -13006,8 +13453,8 @@ var ts;
                     array._children = undefined;
                     // Adjust the pos or end (or both) of the intersecting array accordingly.
                     adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
-                    for (var _i = 0; _i < array.length; _i++) {
-                        var node = array[_i];
+                    for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
+                        var node = array_8[_i];
                         visitNode(node);
                     }
                     return;
@@ -13374,6 +13821,7 @@ var ts;
         var getInstantiatedGlobalPromiseLikeType;
         var getGlobalPromiseConstructorLikeType;
         var getGlobalThenableType;
+        var jsxElementClassType;
         var tupleTypes = {};
         var unionTypes = {};
         var intersectionTypes = {};
@@ -13643,7 +14091,7 @@ var ts;
                     }
                     var initializerOfNonStaticProperty = current.parent &&
                         current.parent.kind === 141 /* PropertyDeclaration */ &&
-                        (current.parent.flags & 128 /* Static */) === 0 &&
+                        (current.parent.flags & 64 /* Static */) === 0 &&
                         current.parent.initializer === current;
                     if (initializerOfNonStaticProperty) {
                         return true;
@@ -13725,7 +14173,7 @@ var ts;
                         // local variables of the constructor. This effectively means that entities from outer scopes
                         // by the same name as a constructor parameter or local variable are inaccessible
                         // in initializer expressions for instance member variables.
-                        if (ts.isClassLike(location.parent) && !(location.flags & 128 /* Static */)) {
+                        if (ts.isClassLike(location.parent) && !(location.flags & 64 /* Static */)) {
                             var ctor = findConstructorDeclaration(location.parent);
                             if (ctor && ctor.locals) {
                                 if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) {
@@ -13739,7 +14187,7 @@ var ts;
                     case 186 /* ClassExpression */:
                     case 215 /* InterfaceDeclaration */:
                         if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) {
-                            if (lastLocation && lastLocation.flags & 128 /* Static */) {
+                            if (lastLocation && lastLocation.flags & 64 /* Static */) {
                                 // TypeScript 1.0 spec (April 2014): 3.4.1
                                 // The scope of a type parameter extends over the entire declaration with which the type
                                 // parameter list is associated, with the exception of static member declarations in classes.
@@ -14267,8 +14715,8 @@ var ts;
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
-            for (var _i = 0; _i < members.length; _i++) {
-                var member = members[_i];
+            for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+                var member = members_1[_i];
                 if (member.kind === 144 /* Constructor */ && ts.nodeIsPresent(member.body)) {
                     return member;
                 }
@@ -14515,7 +14963,7 @@ var ts;
                     // because these kind of aliases can be used to name types in declaration file
                     var anyImportSyntax = getAnyImportSyntax(declaration);
                     if (anyImportSyntax &&
-                        !(anyImportSyntax.flags & 1 /* Export */) &&
+                        !(anyImportSyntax.flags & 2 /* Export */) &&
                         isDeclarationVisible(anyImportSyntax.parent)) {
                         getNodeLinks(declaration).isVisible = true;
                         if (aliasesToMakeVisible) {
@@ -14669,8 +15117,8 @@ var ts;
                             walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning));
                         }
                         if (accessibleSymbolChain) {
-                            for (var _i = 0; _i < accessibleSymbolChain.length; _i++) {
-                                var accessibleSymbol = accessibleSymbolChain[_i];
+                            for (var _i = 0, accessibleSymbolChain_1 = accessibleSymbolChain; _i < accessibleSymbolChain_1.length; _i++) {
+                                var accessibleSymbol = accessibleSymbolChain_1[_i];
                                 appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
                             }
                         }
@@ -14860,7 +15308,7 @@ var ts;
                     }
                     function shouldWriteTypeOfFunctionSymbol() {
                         var isStaticMethodSymbol = !!(symbol.flags & 8192 /* Method */ &&
-                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 128 /* Static */; }));
+                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 64 /* Static */; }));
                         var isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) &&
                             (symbol.parent ||
                                 ts.forEach(symbol.declarations, function (declaration) {
@@ -14971,8 +15419,8 @@ var ts;
                         var t = getTypeOfSymbol(p);
                         if (p.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(t).length) {
                             var signatures = getSignaturesOfType(t, 0 /* Call */);
-                            for (var _f = 0; _f < signatures.length; _f++) {
-                                var signature = signatures[_f];
+                            for (var _f = 0, signatures_1 = signatures; _f < signatures_1.length; _f++) {
+                                var signature = signatures_1[_f];
                                 buildSymbolDisplay(p, writer);
                                 if (p.flags & 536870912 /* Optional */) {
                                     writePunctuation(writer, 53 /* QuestionToken */);
@@ -15186,7 +15634,7 @@ var ts;
                     case 221 /* ImportEqualsDeclaration */:
                         var parent_4 = getDeclarationContainer(node);
                         // If the node is not exported or it is not ambient module element (except import declaration)
-                        if (!(ts.getCombinedNodeFlags(node) & 1 /* Export */) &&
+                        if (!(ts.getCombinedNodeFlags(node) & 2 /* Export */) &&
                             !(node.kind !== 221 /* ImportEqualsDeclaration */ && parent_4.kind !== 248 /* SourceFile */ && ts.isInAmbientContext(parent_4))) {
                             return isGlobalSourceFile(parent_4);
                         }
@@ -15198,7 +15646,7 @@ var ts;
                     case 146 /* SetAccessor */:
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
-                        if (node.flags & (32 /* Private */ | 64 /* Protected */)) {
+                        if (node.flags & (16 /* Private */ | 32 /* Protected */)) {
                             // Private/protected properties/methods are not visible
                             return false;
                         }
@@ -15728,8 +16176,8 @@ var ts;
         // The function allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set
         // in-place and returns the same array.
         function appendTypeParameters(typeParameters, declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
+                var declaration = declarations_2[_i];
                 var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
                 if (!typeParameters) {
                     typeParameters = [tp];
@@ -15934,13 +16382,13 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var declaration = _a[_i];
                 if (declaration.kind === 215 /* InterfaceDeclaration */) {
-                    if (declaration.flags & 524288 /* ContainsThis */) {
+                    if (declaration.flags & 262144 /* ContainsThis */) {
                         return false;
                     }
                     var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
                     if (baseTypeNodes) {
-                        for (var _b = 0; _b < baseTypeNodes.length; _b++) {
-                            var node = baseTypeNodes[_b];
+                        for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
+                            var node = baseTypeNodes_1[_b];
                             if (ts.isSupportedExpressionWithTypeArguments(node)) {
                                 var baseSymbol = resolveEntityName(node.expression, 793056 /* Type */, /*ignoreErrors*/ true);
                                 if (!baseSymbol || !(baseSymbol.flags & 64 /* Interface */) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
@@ -16130,8 +16578,8 @@ var ts;
         }
         function createSymbolTable(symbols) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                var symbol = symbols_1[_i];
                 result[symbol.name] = symbol;
             }
             return result;
@@ -16140,15 +16588,15 @@ var ts;
         // we check symbols to see if we can quickly conclude they are free of "this" references, thus needing no instantiation.
         function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+                var symbol = symbols_2[_i];
                 result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
             }
             return result;
         }
         function addInheritedMembers(symbols, baseSymbols) {
-            for (var _i = 0; _i < baseSymbols.length; _i++) {
-                var s = baseSymbols[_i];
+            for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
+                var s = baseSymbols_1[_i];
                 if (!ts.hasProperty(symbols, s.name)) {
                     symbols[s.name] = s;
                 }
@@ -16156,8 +16604,8 @@ var ts;
         }
         function addInheritedSignatures(signatures, baseSignatures) {
             if (baseSignatures) {
-                for (var _i = 0; _i < baseSignatures.length; _i++) {
-                    var signature = baseSignatures[_i];
+                for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
+                    var signature = baseSignatures_1[_i];
                     signatures.push(signature);
                 }
             }
@@ -16200,8 +16648,8 @@ var ts;
                     members = createSymbolTable(source.declaredProperties);
                 }
                 var thisArgument = ts.lastOrUndefined(typeArguments);
-                for (var _i = 0; _i < baseTypes.length; _i++) {
-                    var baseType = baseTypes[_i];
+                for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
+                    var baseType = baseTypes_1[_i];
                     var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
                     addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
                     callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */));
@@ -16247,8 +16695,8 @@ var ts;
             var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode);
             var typeArgCount = typeArguments ? typeArguments.length : 0;
             var result = [];
-            for (var _i = 0; _i < baseSignatures.length; _i++) {
-                var baseSig = baseSignatures[_i];
+            for (var _i = 0, baseSignatures_2 = baseSignatures; _i < baseSignatures_2.length; _i++) {
+                var baseSig = baseSignatures_2[_i];
                 var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
                 if (typeParamCount === typeArgCount) {
                     var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
@@ -16277,8 +16725,8 @@ var ts;
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
         }
         function findMatchingSignature(signatureList, signature, partialMatch, ignoreReturnTypes) {
-            for (var _i = 0; _i < signatureList.length; _i++) {
-                var s = signatureList[_i];
+            for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
+                var s = signatureList_1[_i];
                 if (compareSignatures(s, signature, partialMatch, ignoreReturnTypes, compareTypes)) {
                     return s;
                 }
@@ -16342,8 +16790,8 @@ var ts;
         }
         function getUnionIndexType(types, kind) {
             var indexTypes = [];
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+                var type = types_1[_i];
                 var indexType = getIndexTypeOfType(type, kind);
                 if (!indexType) {
                     return undefined;
@@ -16522,12 +16970,12 @@ var ts;
         function createUnionOrIntersectionProperty(containingType, name) {
             var types = containingType.types;
             var props;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
+                var current = types_2[_i];
                 var type = getApparentType(current);
                 if (type !== unknownType) {
                     var prop = getPropertyOfType(type, name);
-                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (32 /* Private */ | 64 /* Protected */))) {
+                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (16 /* Private */ | 32 /* Protected */))) {
                         if (!props) {
                             props = [prop];
                         }
@@ -16549,8 +16997,8 @@ var ts;
             }
             var propTypes = [];
             var declarations = [];
-            for (var _a = 0; _a < props.length; _a++) {
-                var prop = props[_a];
+            for (var _a = 0, props_1 = props; _a < props_1.length; _a++) {
+                var prop = props_1[_a];
                 if (prop.declarations) {
                     ts.addRange(declarations, prop.declarations);
                 }
@@ -16908,8 +17356,8 @@ var ts;
         // that care about the presence of such types at arbitrary depth in a containing type.
         function getPropagatingFlagsOfTypes(types) {
             var result = 0;
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
+                var type = types_3[_i];
                 result |= type.flags;
             }
             return result & 14680064 /* PropagatingFlags */;
@@ -17059,8 +17507,8 @@ var ts;
         function getTypeOfGlobalSymbol(symbol, arity) {
             function getTypeDeclaration(symbol) {
                 var declarations = symbol.declarations;
-                for (var _i = 0; _i < declarations.length; _i++) {
-                    var declaration = declarations[_i];
+                for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
+                    var declaration = declarations_3[_i];
                     switch (declaration.kind) {
                         case 214 /* ClassDeclaration */:
                         case 215 /* InterfaceDeclaration */:
@@ -17170,8 +17618,8 @@ var ts;
         // Add the given types to the given type set. Order is preserved, duplicates are removed,
         // and nested types of the given kind are flattened into the set.
         function addTypesToSet(typeSet, types, typeSetKind) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
+                var type = types_4[_i];
                 addTypeToSet(typeSet, type, typeSetKind);
             }
         }
@@ -17193,8 +17641,8 @@ var ts;
             }
         }
         function containsTypeAny(types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
+                var type = types_5[_i];
                 if (isTypeAny(type)) {
                     return true;
                 }
@@ -17310,7 +17758,8 @@ var ts;
             var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false);
             var parent = container && container.parent;
             if (parent && (ts.isClassLike(parent) || parent.kind === 215 /* InterfaceDeclaration */)) {
-                if (!(container.flags & 128 /* Static */)) {
+                if (!(container.flags & 64 /* Static */) &&
+                    (container.kind !== 144 /* Constructor */ || ts.isNodeDescendentOf(node, container.body))) {
                     return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
                 }
             }
@@ -17377,8 +17826,8 @@ var ts;
         function instantiateList(items, mapper, instantiator) {
             if (items && items.length) {
                 var result = [];
-                for (var _i = 0; _i < items.length; _i++) {
-                    var v = items[_i];
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var v = items_1[_i];
                     result.push(instantiator(v, mapper));
                 }
                 return result;
@@ -17417,8 +17866,8 @@ var ts;
                 case 2: return createBinaryTypeEraser(sources[0], sources[1]);
             }
             return function (t) {
-                for (var _i = 0; _i < sources.length; _i++) {
-                    var source = sources[_i];
+                for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
+                    var source = sources_1[_i];
                     if (t === source) {
                         return anyType;
                     }
@@ -17836,8 +18285,8 @@ var ts;
             function eachTypeRelatedToSomeType(source, target) {
                 var result = -1 /* True */;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
+                    var sourceType = sourceTypes_1[_i];
                     var related = typeRelatedToSomeType(sourceType, target, false);
                     if (!related) {
                         return 0 /* False */;
@@ -17859,8 +18308,8 @@ var ts;
             function typeRelatedToEachType(source, target, reportErrors) {
                 var result = -1 /* True */;
                 var targetTypes = target.types;
-                for (var _i = 0; _i < targetTypes.length; _i++) {
-                    var targetType = targetTypes[_i];
+                for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
+                    var targetType = targetTypes_1[_i];
                     var related = isRelatedTo(source, targetType, reportErrors);
                     if (!related) {
                         return 0 /* False */;
@@ -17882,8 +18331,8 @@ var ts;
             function eachTypeRelatedToType(source, target, reportErrors) {
                 var result = -1 /* True */;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_2 = sourceTypes; _i < sourceTypes_2.length; _i++) {
+                    var sourceType = sourceTypes_2[_i];
                     var related = isRelatedTo(sourceType, target, reportErrors);
                     if (!related) {
                         return 0 /* False */;
@@ -18008,8 +18457,8 @@ var ts;
                 var result = -1 /* True */;
                 var properties = getPropertiesOfObjectType(target);
                 var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 524288 /* ObjectLiteral */);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {
+                    var targetProp = properties_1[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
@@ -18023,20 +18472,20 @@ var ts;
                         else if (!(targetProp.flags & 134217728 /* Prototype */)) {
                             var sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
                             var targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
-                            if (sourcePropFlags & 32 /* Private */ || targetPropFlags & 32 /* Private */) {
+                            if (sourcePropFlags & 16 /* Private */ || targetPropFlags & 16 /* Private */) {
                                 if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
                                     if (reportErrors) {
-                                        if (sourcePropFlags & 32 /* Private */ && targetPropFlags & 32 /* Private */) {
+                                        if (sourcePropFlags & 16 /* Private */ && targetPropFlags & 16 /* Private */) {
                                             reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
                                         }
                                         else {
-                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 32 /* Private */ ? source : target), typeToString(sourcePropFlags & 32 /* Private */ ? target : source));
+                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 16 /* Private */ ? source : target), typeToString(sourcePropFlags & 16 /* Private */ ? target : source));
                                         }
                                     }
                                     return 0 /* False */;
                                 }
                             }
-                            else if (targetPropFlags & 64 /* Protected */) {
+                            else if (targetPropFlags & 32 /* Protected */) {
                                 var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32 /* Class */;
                                 var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
                                 var targetClass = getDeclaredTypeOfSymbol(targetProp.parent);
@@ -18047,7 +18496,7 @@ var ts;
                                     return 0 /* False */;
                                 }
                             }
-                            else if (sourcePropFlags & 64 /* Protected */) {
+                            else if (sourcePropFlags & 32 /* Protected */) {
                                 if (reportErrors) {
                                     reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
                                 }
@@ -18089,8 +18538,8 @@ var ts;
                     return 0 /* False */;
                 }
                 var result = -1 /* True */;
-                for (var _i = 0; _i < sourceProperties.length; _i++) {
-                    var sourceProp = sourceProperties[_i];
+                for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
+                    var sourceProp = sourceProperties_1[_i];
                     var targetProp = getPropertyOfObjectType(target, sourceProp.name);
                     if (!targetProp) {
                         return 0 /* False */;
@@ -18130,13 +18579,13 @@ var ts;
                         return result;
                     }
                 }
-                outer: for (var _i = 0; _i < targetSignatures.length; _i++) {
-                    var t = targetSignatures[_i];
+                outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
+                    var t = targetSignatures_1[_i];
                     if (!t.hasStringLiterals || target.flags & 262144 /* FromSignature */) {
                         var localErrors = reportErrors;
                         var checkedAbstractAssignability = false;
-                        for (var _a = 0; _a < sourceSignatures.length; _a++) {
-                            var s = sourceSignatures[_a];
+                        for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) {
+                            var s = sourceSignatures_1[_a];
                             if (!s.hasStringLiterals || source.flags & 262144 /* FromSignature */) {
                                 var related = signatureRelatedTo(s, t, localErrors);
                                 if (related) {
@@ -18167,8 +18616,8 @@ var ts;
                         var targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
                         var sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
                         var targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
-                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 256 /* Abstract */;
-                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 256 /* Abstract */;
+                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 128 /* Abstract */;
+                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 128 /* Abstract */;
                         if (sourceIsAbstract && !(targetIsAbstract && targetDecl)) {
                             // if target isn't a class-declaration type, then it can be new'd, so we forbid the assignment.
                             if (reportErrors) {
@@ -18284,7 +18733,7 @@ var ts;
                 var targetType = getIndexTypeOfType(target, 0 /* String */);
                 if (targetType) {
                     if ((targetType.flags & 1 /* Any */) && !(originalSource.flags & 16777726 /* Primitive */)) {
-                        // non-primitive assignment to any is always allowed, eg 
+                        // non-primitive assignment to any is always allowed, eg
                         //   `var x: { [index: string]: any } = { property: 12 };`
                         return -1 /* True */;
                     }
@@ -18313,7 +18762,7 @@ var ts;
                 var targetType = getIndexTypeOfType(target, 1 /* Number */);
                 if (targetType) {
                     if ((targetType.flags & 1 /* Any */) && !(originalSource.flags & 16777726 /* Primitive */)) {
-                        // non-primitive assignment to any is always allowed, eg 
+                        // non-primitive assignment to any is always allowed, eg
                         //   `var x: { [index: number]: any } = { property: 12 };`
                         return -1 /* True */;
                     }
@@ -18386,8 +18835,8 @@ var ts;
             if (sourceProp === targetProp) {
                 return -1 /* True */;
             }
-            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 /* Private */ | 64 /* Protected */);
-            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 /* Private */ | 64 /* Protected */);
+            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (16 /* Private */ | 32 /* Protected */);
+            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (16 /* Private */ | 32 /* Protected */);
             if (sourcePropAccessibility !== targetPropAccessibility) {
                 return 0 /* False */;
             }
@@ -18455,8 +18904,8 @@ var ts;
             return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1;
         }
         function isSupertypeOfEach(candidate, types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_6 = types; _i < types_6.length; _i++) {
+                var type = types_6[_i];
                 if (candidate !== type && !isTypeSubtypeOf(type, candidate))
                     return false;
             }
@@ -18692,8 +19141,8 @@ var ts;
         }
         function createInferenceContext(typeParameters, inferUnionTypes) {
             var inferences = [];
-            for (var _i = 0; _i < typeParameters.length; _i++) {
-                var unused = typeParameters[_i];
+            for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
+                var unused = typeParameters_1[_i];
                 inferences.push({
                     primary: undefined, secondary: undefined, isFixed: false
                 });
@@ -18774,8 +19223,8 @@ var ts;
                     var typeParameterCount = 0;
                     var typeParameter;
                     // First infer to each type in union or intersection that isn't a type parameter
-                    for (var _i = 0; _i < targetTypes.length; _i++) {
-                        var t = targetTypes[_i];
+                    for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
+                        var t = targetTypes_2[_i];
                         if (t.flags & 512 /* TypeParameter */ && ts.contains(context.typeParameters, t)) {
                             typeParameter = t;
                             typeParameterCount++;
@@ -18797,8 +19246,8 @@ var ts;
                 else if (source.flags & 49152 /* UnionOrIntersection */) {
                     // Source is a union or intersection type, infer from each consituent type
                     var sourceTypes = source.types;
-                    for (var _a = 0; _a < sourceTypes.length; _a++) {
-                        var sourceType = sourceTypes[_a];
+                    for (var _a = 0, sourceTypes_3 = sourceTypes; _a < sourceTypes_3.length; _a++) {
+                        var sourceType = sourceTypes_3[_a];
                         inferFromTypes(sourceType, target);
                     }
                 }
@@ -18832,8 +19281,8 @@ var ts;
             }
             function inferFromProperties(source, target) {
                 var properties = getPropertiesOfObjectType(target);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_2 = properties; _i < properties_2.length; _i++) {
+                    var targetProp = properties_2[_i];
                     var sourceProp = getPropertyOfObjectType(source, targetProp.name);
                     if (sourceProp) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
@@ -19324,9 +19773,9 @@ var ts;
                 symbol.valueDeclaration.parent.kind === 244 /* CatchClause */) {
                 return;
             }
-            // 1. walk from the use site up to the declaration and check 
+            // 1. walk from the use site up to the declaration and check
             // if there is anything function like between declaration and use-site (is binding/class is captured in function).
-            // 2. walk from the declaration up to the boundary of lexical environment and check 
+            // 2. walk from the declaration up to the boundary of lexical environment and check
             // if there is an iteration statement in between declaration and boundary (is binding/class declared inside iteration statement)
             var container;
             if (symbol.flags & 32 /* Class */) {
@@ -19398,7 +19847,7 @@ var ts;
                     break;
                 case 141 /* PropertyDeclaration */:
                 case 140 /* PropertySignature */:
-                    if (container.flags & 128 /* Static */) {
+                    if (container.flags & 64 /* Static */) {
                         error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
                     }
                     break;
@@ -19411,7 +19860,7 @@ var ts;
             }
             if (ts.isClassLike(container.parent)) {
                 var symbol = getSymbolOfNode(container.parent);
-                return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
+                return container.flags & 64 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
             }
             return anyType;
         }
@@ -19441,7 +19890,7 @@ var ts;
             var nodeCheckFlag = 0;
             // always set NodeCheckFlags for 'super' expression node
             if (canUseSuperExpression) {
-                if ((container.flags & 128 /* Static */) || isCallExpression) {
+                if ((container.flags & 64 /* Static */) || isCallExpression) {
                     nodeCheckFlag = 512 /* SuperStatic */;
                 }
                 else {
@@ -19497,7 +19946,7 @@ var ts;
                     // - In a static member function or static member accessor
                     // topmost container must be something that is directly nested in the class declaration
                     if (container && ts.isClassLike(container.parent)) {
-                        if (container.flags & 128 /* Static */) {
+                        if (container.flags & 64 /* Static */) {
                             return container.kind === 143 /* MethodDeclaration */ ||
                                 container.kind === 142 /* MethodSignature */ ||
                                 container.kind === 145 /* GetAccessor */ ||
@@ -19654,8 +20103,8 @@ var ts;
             var types = type.types;
             var mappedType;
             var mappedTypes;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
+                var current = types_7[_i];
                 var t = mapper(current);
                 if (t) {
                     if (!mappedType) {
@@ -19845,8 +20294,8 @@ var ts;
             }
             var signatureList;
             var types = type.types;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
+                var current = types_8[_i];
                 var signature = getNonGenericSignature(current);
                 if (signature) {
                     if (!signatureList) {
@@ -19926,8 +20375,8 @@ var ts;
             var hasSpreadElement = false;
             var elementTypes = [];
             var inDestructuringPattern = isAssignmentTarget(node);
-            for (var _i = 0; _i < elements.length; _i++) {
-                var e = elements[_i];
+            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+                var e = elements_1[_i];
                 if (inDestructuringPattern && e.kind === 185 /* SpreadElementExpression */) {
                     // Given the following situation:
                     //    var c: {};
@@ -20259,8 +20708,8 @@ var ts;
         function checkJsxSpreadAttribute(node, elementAttributesType, nameTable) {
             var type = checkExpression(node.expression);
             var props = getPropertiesOfType(type);
-            for (var _i = 0; _i < props.length; _i++) {
-                var prop = props[_i];
+            for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+                var prop = props_2[_i];
                 // Is there a corresponding property in the element attributes type? Skip checking of properties
                 // that have already been assigned to, as these are not actually pushed into the resulting type
                 if (!nameTable[prop.name]) {
@@ -20479,7 +20928,6 @@ var ts;
             var prop = getPropertyOfType(attributesType, attrib.name.text);
             return prop || unknownSymbol;
         }
-        var jsxElementClassType = undefined;
         function getJsxGlobalElementClassType() {
             if (!jsxElementClassType) {
                 jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
@@ -20558,7 +21006,7 @@ var ts;
             return s.valueDeclaration ? s.valueDeclaration.kind : 141 /* PropertyDeclaration */;
         }
         function getDeclarationFlagsFromSymbol(s) {
-            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 16 /* Public */ | 128 /* Static */ : 0;
+            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 8 /* Public */ | 64 /* Static */ : 0;
         }
         /**
          * Check whether the requested property access is valid.
@@ -20588,7 +21036,7 @@ var ts;
                     error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
                     return false;
                 }
-                if (flags & 256 /* Abstract */) {
+                if (flags & 128 /* Abstract */) {
                     // A method cannot be accessed in a super property access if the method is abstract.
                     // This error could mask a private property access error. But, a member
                     // cannot simultaneously be private and abstract, so this will trigger an
@@ -20598,7 +21046,7 @@ var ts;
                 }
             }
             // Public properties are otherwise accessible.
-            if (!(flags & (32 /* Private */ | 64 /* Protected */))) {
+            if (!(flags & (16 /* Private */ | 32 /* Protected */))) {
                 return true;
             }
             // Property is known to be private or protected at this point
@@ -20606,7 +21054,7 @@ var ts;
             var enclosingClassDeclaration = ts.getContainingClass(node);
             var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
             // Private property is accessible if declaring and enclosing class are the same
-            if (flags & 32 /* Private */) {
+            if (flags & 16 /* Private */) {
                 if (declaringClass !== enclosingClass) {
                     error(node, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass));
                     return false;
@@ -20624,7 +21072,7 @@ var ts;
                 return false;
             }
             // No further restrictions for static properties
-            if (flags & 128 /* Static */) {
+            if (flags & 64 /* Static */) {
                 return true;
             }
             // An instance property must be accessed through an instance of the enclosing class
@@ -20851,8 +21299,8 @@ var ts;
             var specializedIndex = -1;
             var spliceIndex;
             ts.Debug.assert(!result.length);
-            for (var _i = 0; _i < signatures.length; _i++) {
-                var signature = signatures[_i];
+            for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
+                var signature = signatures_2[_i];
                 var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
                 var parent_5 = signature.declaration && signature.declaration.parent;
                 if (!lastSymbol || symbol === lastSymbol) {
@@ -21494,8 +21942,8 @@ var ts;
             //  declare function f(a: { xa: number; xb: number; });
             //  f({ |
             if (!produceDiagnostics) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var candidate = candidates[_i];
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
                     if (hasCorrectArity(node, args, candidate)) {
                         if (candidate.typeParameters && typeArguments) {
                             candidate = getSignatureInstantiation(candidate, ts.map(typeArguments, getTypeFromTypeNode));
@@ -21514,8 +21962,8 @@ var ts;
                 diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo));
             }
             function chooseOverload(candidates, relation) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var originalCandidate = candidates[_i];
+                for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+                    var originalCandidate = candidates_2[_i];
                     if (!hasCorrectArity(node, args, originalCandidate)) {
                         continue;
                     }
@@ -21652,7 +22100,7 @@ var ts;
             // In the case of a merged class-module or class-interface declaration,
             // only the class declaration node will have the Abstract flag set.
             var valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-            if (valueDecl && valueDecl.flags & 256 /* Abstract */) {
+            if (valueDecl && valueDecl.flags & 128 /* Abstract */) {
                 error(node, ts.Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, ts.declarationNameToString(valueDecl.name));
                 return resolveErrorCall(node);
             }
@@ -22017,19 +22465,11 @@ var ts;
             });
             return aggregatedTypes;
         }
-        function bodyContainsAReturnStatement(funcBody) {
-            return ts.forEachReturnStatement(funcBody, function (returnStatement) {
-                return true;
-            });
-        }
-        function bodyContainsSingleThrowStatement(body) {
-            return (body.statements.length === 1) && (body.statements[0].kind === 208 /* ThrowStatement */);
-        }
         // TypeScript Specification 1.0 (6.3) - July 2014
         // An explicitly typed function whose return type isn't the Void or the Any type
         // must have at least one return statement somewhere in its body.
         // An exception to this rule is if the function implementation consists of a single 'throw' statement.
-        function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) {
+        function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
             if (!produceDiagnostics) {
                 return;
             }
@@ -22038,22 +22478,19 @@ var ts;
                 return;
             }
             // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check.
-            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192 /* Block */) {
+            // also if HasImplicitReturnValue flags is not set this means that all codepaths in function body end with return of throw
+            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192 /* Block */ || !(func.flags & 524288 /* HasImplicitReturn */)) {
                 return;
             }
-            var bodyBlock = func.body;
-            // Ensure the body has at least one return expression.
-            if (bodyContainsAReturnStatement(bodyBlock)) {
-                return;
+            if (func.flags & 1048576 /* HasExplicitReturn */) {
+                if (compilerOptions.noImplicitReturns) {
+                    error(func.type, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                }
             }
-            // If there are no return expressions, then we need to check if
-            // the function body consists solely of a throw statement;
-            // this is to make an exception for unimplemented functions.
-            if (bodyContainsSingleThrowStatement(bodyBlock)) {
-                return;
+            else {
+                // This function does not conform to the specification.
+                error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
             }
-            // This function does not conform to the specification.
-            error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement);
         }
         function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) {
             ts.Debug.assert(node.kind !== 143 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
@@ -22120,7 +22557,7 @@ var ts;
                 promisedType = checkAsyncFunctionReturnType(node);
             }
             if (returnType && !node.asteriskToken) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (node.body) {
                 if (!node.type) {
@@ -22205,7 +22642,7 @@ var ts;
                     case 69 /* Identifier */:
                     case 166 /* PropertyAccessExpression */: {
                         var symbol = findSymbol(n);
-                        return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 32768 /* Const */) !== 0;
+                        return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 16384 /* Const */) !== 0;
                     }
                     case 167 /* ElementAccessExpression */: {
                         var index = n.argumentExpression;
@@ -22213,7 +22650,7 @@ var ts;
                         if (symbol && index && index.kind === 9 /* StringLiteral */) {
                             var name_12 = index.text;
                             var prop = getPropertyOfType(getTypeOfSymbol(symbol), name_12);
-                            return prop && (prop.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 32768 /* Const */) !== 0;
+                            return prop && (prop.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 16384 /* Const */) !== 0;
                         }
                         return false;
                     }
@@ -22298,8 +22735,8 @@ var ts;
             }
             if (type.flags & 49152 /* UnionOrIntersection */) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
+                    var current = types_9[_i];
                     if (current.flags & kind) {
                         return true;
                     }
@@ -22315,8 +22752,8 @@ var ts;
             }
             if (type.flags & 49152 /* UnionOrIntersection */) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
+                    var current = types_10[_i];
                     if (!(current.flags & kind)) {
                         return false;
                     }
@@ -22361,8 +22798,8 @@ var ts;
         }
         function checkObjectLiteralAssignment(node, sourceType, contextualMapper) {
             var properties = node.properties;
-            for (var _i = 0; _i < properties.length; _i++) {
-                var p = properties[_i];
+            for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
+                var p = properties_3[_i];
                 if (p.kind === 245 /* PropertyAssignment */ || p.kind === 246 /* ShorthandPropertyAssignment */) {
                     // TODO(andersh): Computed property support
                     var name_13 = p.name;
@@ -22896,7 +23333,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             checkVariableLikeDeclaration(node);
             var func = ts.getContainingFunction(node);
-            if (node.flags & 112 /* AccessibilityModifier */) {
+            if (node.flags & 56 /* AccessibilityModifier */) {
                 func = ts.getContainingFunction(node);
                 if (!(func.kind === 144 /* Constructor */ && ts.nodeIsPresent(func.body))) {
                     error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
@@ -23096,7 +23533,7 @@ var ts;
             checkFunctionLikeDeclaration(node);
             // Abstract methods cannot have an implementation.
             // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node.
-            if (node.flags & 256 /* Abstract */ && node.body) {
+            if (node.flags & 128 /* Abstract */ && node.body) {
                 error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
             }
         }
@@ -23147,7 +23584,7 @@ var ts;
             }
             function isInstancePropertyWithInitializer(n) {
                 return n.kind === 141 /* PropertyDeclaration */ &&
-                    !(n.flags & 128 /* Static */) &&
+                    !(n.flags & 64 /* Static */) &&
                     !!n.initializer;
             }
             // TS 1.0 spec (April 2014): 8.3.2
@@ -23168,14 +23605,14 @@ var ts;
                     // - The constructor declares parameter properties
                     //   or the containing class declares instance member variables with initializers.
                     var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) ||
-                        ts.forEach(node.parameters, function (p) { return p.flags & (16 /* Public */ | 32 /* Private */ | 64 /* Protected */); });
+                        ts.forEach(node.parameters, function (p) { return p.flags & (8 /* Public */ | 16 /* Private */ | 32 /* Protected */); });
                     // Skip past any prologue directives to find the first statement
                     // to ensure that it was a super call.
                     if (superCallShouldBeFirst) {
                         var statements = node.body.statements;
                         var superCallStatement;
-                        for (var _i = 0; _i < statements.length; _i++) {
-                            var statement = statements[_i];
+                        for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
+                            var statement = statements_2[_i];
                             if (statement.kind === 195 /* ExpressionStatement */ && isSuperCallExpression(statement.expression)) {
                                 superCallStatement = statement;
                                 break;
@@ -23203,8 +23640,15 @@ var ts;
                 // Grammar checking accessors
                 checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
                 if (node.kind === 145 /* GetAccessor */) {
-                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) {
-                        error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);
+                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && (node.flags & 524288 /* HasImplicitReturn */)) {
+                        if (node.flags & 1048576 /* HasExplicitReturn */) {
+                            if (compilerOptions.noImplicitReturns) {
+                                error(node.name, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                            }
+                        }
+                        else {
+                            error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
+                        }
                     }
                 }
                 if (!ts.hasDynamicName(node)) {
@@ -23213,7 +23657,7 @@ var ts;
                     var otherKind = node.kind === 145 /* GetAccessor */ ? 146 /* SetAccessor */ : 145 /* GetAccessor */;
                     var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind);
                     if (otherAccessor) {
-                        if (((node.flags & 112 /* AccessibilityModifier */) !== (otherAccessor.flags & 112 /* AccessibilityModifier */))) {
+                        if (((node.flags & 56 /* AccessibilityModifier */) !== (otherAccessor.flags & 56 /* AccessibilityModifier */))) {
                             error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
                         }
                         var currentAccessorType = getAnnotatedAccessorType(node);
@@ -23284,7 +23728,7 @@ var ts;
             ts.forEach(node.types, checkSourceElement);
         }
         function isPrivateWithinAmbient(node) {
-            return (node.flags & 32 /* Private */) && ts.isInAmbientContext(node);
+            return (node.flags & 16 /* Private */) && ts.isInAmbientContext(node);
         }
         function checkSpecializedSignatureDeclaration(signatureDeclarationNode) {
             if (!produceDiagnostics) {
@@ -23316,8 +23760,8 @@ var ts;
             else {
                 signaturesToCheck = getSignaturesOfSymbol(getSymbolOfNode(signatureDeclarationNode));
             }
-            for (var _i = 0; _i < signaturesToCheck.length; _i++) {
-                var otherSignature = signaturesToCheck[_i];
+            for (var _i = 0, signaturesToCheck_1 = signaturesToCheck; _i < signaturesToCheck_1.length; _i++) {
+                var otherSignature = signaturesToCheck_1[_i];
                 if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) {
                     return;
                 }
@@ -23332,11 +23776,11 @@ var ts;
                 n.parent.kind !== 214 /* ClassDeclaration */ &&
                 n.parent.kind !== 186 /* ClassExpression */ &&
                 ts.isInAmbientContext(n)) {
-                if (!(flags & 2 /* Ambient */)) {
+                if (!(flags & 4 /* Ambient */)) {
                     // It is nested in an ambient context, which means it is automatically exported
-                    flags |= 1 /* Export */;
+                    flags |= 2 /* Export */;
                 }
-                flags |= 2 /* Ambient */;
+                flags |= 4 /* Ambient */;
             }
             return flags & flagsToCheck;
         }
@@ -23361,16 +23805,16 @@ var ts;
                     var canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
                     ts.forEach(overloads, function (o) {
                         var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags;
-                        if (deviation & 1 /* Export */) {
+                        if (deviation & 2 /* Export */) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported);
                         }
-                        else if (deviation & 2 /* Ambient */) {
+                        else if (deviation & 4 /* Ambient */) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
                         }
-                        else if (deviation & (32 /* Private */ | 64 /* Protected */)) {
+                        else if (deviation & (16 /* Private */ | 32 /* Protected */)) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
                         }
-                        else if (deviation & 256 /* Abstract */) {
+                        else if (deviation & 128 /* Abstract */) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract);
                         }
                     });
@@ -23387,7 +23831,7 @@ var ts;
                     });
                 }
             }
-            var flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 32 /* Private */ | 64 /* Protected */ | 256 /* Abstract */;
+            var flagsToCheck = 2 /* Export */ | 4 /* Ambient */ | 16 /* Private */ | 32 /* Protected */ | 128 /* Abstract */;
             var someNodeFlags = 0;
             var allNodeFlags = flagsToCheck;
             var someHaveQuestionToken = false;
@@ -23418,8 +23862,8 @@ var ts;
                         if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) {
                             // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members
                             ts.Debug.assert(node.kind === 143 /* MethodDeclaration */ || node.kind === 142 /* MethodSignature */);
-                            ts.Debug.assert((node.flags & 128 /* Static */) !== (subsequentNode.flags & 128 /* Static */));
-                            var diagnostic = node.flags & 128 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
+                            ts.Debug.assert((node.flags & 64 /* Static */) !== (subsequentNode.flags & 64 /* Static */));
+                            var diagnostic = node.flags & 64 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
                             error(errorNode_1, diagnostic);
                             return;
                         }
@@ -23436,7 +23880,7 @@ var ts;
                 else {
                     // Report different errors regarding non-consecutive blocks of declarations depending on whether
                     // the node in question is abstract.
-                    if (node.flags & 256 /* Abstract */) {
+                    if (node.flags & 128 /* Abstract */) {
                         error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
                     }
                     else {
@@ -23449,8 +23893,8 @@ var ts;
             var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536 /* Module */;
             var duplicateFunctionDeclaration = false;
             var multipleConstructorImplementation = false;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var current = declarations[_i];
+            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                var current = declarations_4[_i];
                 var node = current;
                 var inAmbientContext = ts.isInAmbientContext(node);
                 var inAmbientContextOrInterface = node.parent.kind === 215 /* InterfaceDeclaration */ || node.parent.kind === 155 /* TypeLiteral */ || inAmbientContext;
@@ -23507,7 +23951,7 @@ var ts;
             }
             // Abstract methods can't have an implementation -- in particular, they don't need one.
             if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
-                !(lastSeenNonAmbientDeclaration.flags & 256 /* Abstract */)) {
+                !(lastSeenNonAmbientDeclaration.flags & 128 /* Abstract */)) {
                 reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
             }
             if (hasOverloads) {
@@ -23533,8 +23977,8 @@ var ts;
                         // function g(x: string, y: string) { }
                         //
                         // The implementation is completely unrelated to the specialized signature, yet we do not check this.
-                        for (var _a = 0; _a < signatures.length; _a++) {
-                            var signature = signatures[_a];
+                        for (var _a = 0, signatures_3 = signatures; _a < signatures_3.length; _a++) {
+                            var signature = signatures_3[_a];
                             if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) {
                                 error(signature.declaration, ts.Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
                                 break;
@@ -23571,9 +24015,9 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var d = _a[_i];
                 var declarationSpaces = getDeclarationSpaces(d);
-                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 1024 /* Default */);
-                if (effectiveDeclarationFlags & 1 /* Export */) {
-                    if (effectiveDeclarationFlags & 1024 /* Default */) {
+                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 2 /* Export */ | 512 /* Default */);
+                if (effectiveDeclarationFlags & 2 /* Export */) {
+                    if (effectiveDeclarationFlags & 512 /* Default */) {
                         defaultExportedDeclarationSpaces |= declarationSpaces;
                     }
                     else {
@@ -23826,9 +24270,12 @@ var ts;
                 // type as a value. As such, we will just return unknownType;
                 return unknownType;
             }
-            var promiseConstructor = getMergedSymbol(promiseType.symbol);
+            var promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
             if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
-                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType));
+                var typeName = promiseConstructor
+                    ? symbolToString(promiseConstructor)
+                    : typeToString(promiseType);
+                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeName);
                 return unknownType;
             }
             // Validate the promise constructor type.
@@ -24020,7 +24467,7 @@ var ts;
                 if (isAsync) {
                     promisedType = checkAsyncFunctionReturnType(node);
                 }
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (produceDiagnostics && !node.type) {
                 // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
@@ -24162,7 +24609,7 @@ var ts;
             //          let x = 0; // symbol for this declaration will be 'symbol'
             //      }
             // skip block-scoped variables and parameters
-            if ((ts.getCombinedNodeFlags(node) & 49152 /* BlockScoped */) !== 0 || ts.isParameterDeclaration(node)) {
+            if ((ts.getCombinedNodeFlags(node) & 24576 /* BlockScoped */) !== 0 || ts.isParameterDeclaration(node)) {
                 return;
             }
             // skip variable declarations that don't have initializers
@@ -24177,7 +24624,7 @@ var ts;
                 if (localDeclarationSymbol &&
                     localDeclarationSymbol !== symbol &&
                     localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) {
-                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 49152 /* BlockScoped */) {
+                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 24576 /* BlockScoped */) {
                         var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 212 /* VariableDeclarationList */);
                         var container = varDeclList.parent.kind === 193 /* VariableStatement */ && varDeclList.parent.parent
                             ? varDeclList.parent.parent
@@ -24330,6 +24777,9 @@ var ts;
             checkGrammarStatementInAmbientContext(node);
             checkExpression(node.expression);
             checkSourceElement(node.thenStatement);
+            if (node.thenStatement.kind === 194 /* EmptyStatement */) {
+                error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
+            }
             checkSourceElement(node.elseStatement);
         }
         function checkDoStatement(node) {
@@ -24688,7 +25138,7 @@ var ts;
                         error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value);
                     }
                     else if (func.kind === 144 /* Constructor */) {
-                        if (!isTypeAssignableTo(exprType, returnType)) {
+                        if (!checkTypeAssignableTo(exprType, returnType, node.expression)) {
                             error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
                         }
                     }
@@ -24835,7 +25285,7 @@ var ts;
                         // Only process instance properties with computed names here.
                         // Static properties cannot be in conflict with indexers,
                         // and properties with literal names were already checked.
-                        if (!(member.flags & 128 /* Static */) && ts.hasDynamicName(member)) {
+                        if (!(member.flags & 64 /* Static */) && ts.hasDynamicName(member)) {
                             var propType = getTypeOfSymbol(member.symbol);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */);
@@ -24921,7 +25371,7 @@ var ts;
             return getTypeOfSymbol(getSymbolOfNode(node));
         }
         function checkClassDeclaration(node) {
-            if (!node.name && !(node.flags & 1024 /* Default */)) {
+            if (!node.name && !(node.flags & 512 /* Default */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
             }
             checkClassLikeDeclaration(node);
@@ -24975,8 +25425,8 @@ var ts;
             }
             var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
-                for (var _b = 0; _b < implementedTypeNodes.length; _b++) {
-                    var typeRefNode = implementedTypeNodes[_b];
+                for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
+                    var typeRefNode = implementedTypeNodes_1[_b];
                     if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) {
                         error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
@@ -25024,8 +25474,8 @@ var ts;
             // derived class instance member variables and accessors, but not by other kinds of members.
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfObjectType(baseType);
-            for (var _i = 0; _i < baseProperties.length; _i++) {
-                var baseProperty = baseProperties[_i];
+            for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 134217728 /* Prototype */) {
                     continue;
@@ -25043,7 +25493,7 @@ var ts;
                         // It is an error to inherit an abstract member without implementing it or being declared abstract.
                         // If there is no declaration for the derived class (as in the case of class expressions),
                         // then the class cannot be declared abstract.
-                        if (baseDeclarationFlags & 256 /* Abstract */ && (!derivedClassDecl || !(derivedClassDecl.flags & 256 /* Abstract */))) {
+                        if (baseDeclarationFlags & 128 /* Abstract */ && (!derivedClassDecl || !(derivedClassDecl.flags & 128 /* Abstract */))) {
                             if (derivedClassDecl.kind === 186 /* ClassExpression */) {
                                 error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
                             }
@@ -25055,11 +25505,11 @@ var ts;
                     else {
                         // derived overrides base.
                         var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
-                        if ((baseDeclarationFlags & 32 /* Private */) || (derivedDeclarationFlags & 32 /* Private */)) {
+                        if ((baseDeclarationFlags & 16 /* Private */) || (derivedDeclarationFlags & 16 /* Private */)) {
                             // either base or derived property is private - not override, skip it
                             continue;
                         }
-                        if ((baseDeclarationFlags & 128 /* Static */) !== (derivedDeclarationFlags & 128 /* Static */)) {
+                        if ((baseDeclarationFlags & 64 /* Static */) !== (derivedDeclarationFlags & 64 /* Static */)) {
                             // value of 'static' is not the same for properties - not override, skip it
                             continue;
                         }
@@ -25130,11 +25580,11 @@ var ts;
             var seen = {};
             ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen[p.name] = { prop: p, containingType: type }; });
             var ok = true;
-            for (var _i = 0; _i < baseTypes.length; _i++) {
-                var base = baseTypes[_i];
+            for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
+                var base = baseTypes_2[_i];
                 var properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var prop = properties[_a];
+                for (var _a = 0, properties_4 = properties; _a < properties_4.length; _a++) {
+                    var prop = properties_4[_a];
                     if (!ts.hasProperty(seen, prop.name)) {
                         seen[prop.name] = { prop: prop, containingType: base };
                     }
@@ -25431,8 +25881,8 @@ var ts;
         }
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
             var declarations = symbol.declarations;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+                var declaration = declarations_5[_i];
                 if ((declaration.kind === 214 /* ClassDeclaration */ ||
                     (declaration.kind === 213 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) &&
                     !ts.isInAmbientContext(declaration)) {
@@ -25571,7 +26021,7 @@ var ts;
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035 /* Modifier */)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022 /* Modifier */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
             }
             if (checkExternalImportOrExportDeclaration(node)) {
@@ -25599,7 +26049,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
                 checkImportBinding(node);
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     markExportAsReferenced(node);
                 }
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
@@ -25630,7 +26080,7 @@ var ts;
                 // If we hit an export in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035 /* Modifier */)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022 /* Modifier */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
             }
             if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
@@ -25674,7 +26124,7 @@ var ts;
                 return;
             }
             // Grammar checking
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035 /* Modifier */)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022 /* Modifier */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
             }
             if (node.expression.kind === 69 /* Identifier */) {
@@ -26087,7 +26537,7 @@ var ts;
                             // add the type parameters into the symbol table
                             // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol.
                             // Note: that the memberFlags come from previous iteration.
-                            if (!(memberFlags & 128 /* Static */)) {
+                            if (!(memberFlags & 64 /* Static */)) {
                                 copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */);
                             }
                             break;
@@ -26388,7 +26838,7 @@ var ts;
           */
         function getParentTypeOfClassElement(node) {
             var classSymbol = getSymbolOfNode(node.parent);
-            return node.flags & 128 /* Static */
+            return node.flags & 64 /* Static */
                 ? getTypeOfSymbol(classSymbol)
                 : getDeclaredTypeOfSymbol(classSymbol);
         }
@@ -26709,7 +27159,7 @@ var ts;
         function initializeTypeChecker() {
             // Bind all source files and propagate errors
             ts.forEach(host.getSourceFiles(), function (file) {
-                ts.bindSourceFile(file);
+                ts.bindSourceFile(file, compilerOptions);
             });
             // Initialize global symbol table
             ts.forEach(host.getSourceFiles(), function (file) {
@@ -26863,19 +27313,19 @@ var ts;
                             text = "private";
                             lastPrivate = modifier;
                         }
-                        if (flags & 112 /* AccessibilityModifier */) {
+                        if (flags & 56 /* AccessibilityModifier */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
                         }
-                        else if (flags & 128 /* Static */) {
+                        else if (flags & 64 /* Static */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
                         }
                         else if (node.parent.kind === 219 /* ModuleBlock */ || node.parent.kind === 248 /* SourceFile */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text);
                         }
-                        else if (flags & 256 /* Abstract */) {
+                        else if (flags & 128 /* Abstract */) {
                             if (modifier.kind === 110 /* PrivateKeyword */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
                             }
@@ -26886,10 +27336,10 @@ var ts;
                         flags |= ts.modifierToFlag(modifier.kind);
                         break;
                     case 113 /* StaticKeyword */:
-                        if (flags & 128 /* Static */) {
+                        if (flags & 64 /* Static */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
                         }
                         else if (node.parent.kind === 219 /* ModuleBlock */ || node.parent.kind === 248 /* SourceFile */) {
@@ -26898,23 +27348,23 @@ var ts;
                         else if (node.kind === 138 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
                         }
-                        else if (flags & 256 /* Abstract */) {
+                        else if (flags & 128 /* Abstract */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                         }
-                        flags |= 128 /* Static */;
+                        flags |= 64 /* Static */;
                         lastStatic = modifier;
                         break;
                     case 82 /* ExportKeyword */:
-                        if (flags & 1 /* Export */) {
+                        if (flags & 2 /* Export */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
                         }
-                        else if (flags & 2 /* Ambient */) {
+                        else if (flags & 4 /* Ambient */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
                         }
-                        else if (flags & 256 /* Abstract */) {
+                        else if (flags & 128 /* Abstract */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
                         }
                         else if (node.parent.kind === 214 /* ClassDeclaration */) {
@@ -26923,13 +27373,13 @@ var ts;
                         else if (node.kind === 138 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
                         }
-                        flags |= 1 /* Export */;
+                        flags |= 2 /* Export */;
                         break;
                     case 122 /* DeclareKeyword */:
-                        if (flags & 2 /* Ambient */) {
+                        if (flags & 4 /* Ambient */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.parent.kind === 214 /* ClassDeclaration */) {
@@ -26941,69 +27391,69 @@ var ts;
                         else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 219 /* ModuleBlock */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
                         }
-                        flags |= 2 /* Ambient */;
+                        flags |= 4 /* Ambient */;
                         lastDeclare = modifier;
                         break;
                     case 115 /* AbstractKeyword */:
-                        if (flags & 256 /* Abstract */) {
+                        if (flags & 128 /* Abstract */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
                         }
                         if (node.kind !== 214 /* ClassDeclaration */) {
                             if (node.kind !== 143 /* MethodDeclaration */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_or_method_declaration);
                             }
-                            if (!(node.parent.kind === 214 /* ClassDeclaration */ && node.parent.flags & 256 /* Abstract */)) {
+                            if (!(node.parent.kind === 214 /* ClassDeclaration */ && node.parent.flags & 128 /* Abstract */)) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
                             }
-                            if (flags & 128 /* Static */) {
+                            if (flags & 64 /* Static */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                             }
-                            if (flags & 32 /* Private */) {
+                            if (flags & 16 /* Private */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
                             }
                         }
-                        flags |= 256 /* Abstract */;
+                        flags |= 128 /* Abstract */;
                         break;
                     case 118 /* AsyncKeyword */:
-                        if (flags & 512 /* Async */) {
+                        if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
                         }
-                        else if (flags & 2 /* Ambient */ || ts.isInAmbientContext(node.parent)) {
+                        else if (flags & 4 /* Ambient */ || ts.isInAmbientContext(node.parent)) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.kind === 138 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
                         }
-                        flags |= 512 /* Async */;
+                        flags |= 256 /* Async */;
                         lastAsync = modifier;
                         break;
                 }
             }
             if (node.kind === 144 /* Constructor */) {
-                if (flags & 128 /* Static */) {
+                if (flags & 64 /* Static */) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
                 }
-                if (flags & 256 /* Abstract */) {
+                if (flags & 128 /* Abstract */) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
                 }
-                else if (flags & 64 /* Protected */) {
+                else if (flags & 32 /* Protected */) {
                     return grammarErrorOnNode(lastProtected, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected");
                 }
-                else if (flags & 32 /* Private */) {
+                else if (flags & 16 /* Private */) {
                     return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private");
                 }
-                else if (flags & 512 /* Async */) {
+                else if (flags & 256 /* Async */) {
                     return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
                 }
                 return;
             }
-            else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
+            else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && flags & 4 /* Ambient */) {
                 return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
             }
-            else if (node.kind === 138 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) {
+            else if (node.kind === 138 /* Parameter */ && (flags & 56 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) {
                 return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern);
             }
-            if (flags & 512 /* Async */) {
+            if (flags & 256 /* Async */) {
                 return checkGrammarAsyncModifier(node, lastAsync);
             }
         }
@@ -27104,7 +27554,7 @@ var ts;
             if (parameter.dotDotDotToken) {
                 return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
             }
-            if (parameter.flags & 2035 /* Modifier */) {
+            if (parameter.flags & 1022 /* Modifier */) {
                 return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
             }
             if (parameter.questionToken) {
@@ -27124,7 +27574,7 @@ var ts;
             }
         }
         function checkGrammarForIndexSignatureModifier(node) {
-            if (node.flags & 2035 /* Modifier */) {
+            if (node.flags & 1022 /* Modifier */) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_not_permitted_on_index_signature_members);
             }
         }
@@ -27147,8 +27597,8 @@ var ts;
         function checkGrammarForOmittedArgument(node, args) {
             if (args) {
                 var sourceFile = ts.getSourceFileOfNode(node);
-                for (var _i = 0; _i < args.length; _i++) {
-                    var arg = args[_i];
+                for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+                    var arg = args_1[_i];
                     if (arg.kind === 187 /* OmittedExpression */) {
                         return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
                     }
@@ -27403,7 +27853,7 @@ var ts;
                     if (parameter.dotDotDotToken) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
                     }
-                    else if (parameter.flags & 2035 /* Modifier */) {
+                    else if (parameter.flags & 1022 /* Modifier */) {
                         return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
                     }
                     else if (parameter.questionToken) {
@@ -27554,8 +28004,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0; _i < elements.length; _i++) {
-                    var element = elements[_i];
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
                     if (element.kind !== 187 /* OmittedExpression */) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -27691,8 +28141,8 @@ var ts;
                 node.kind === 221 /* ImportEqualsDeclaration */ ||
                 node.kind === 228 /* ExportDeclaration */ ||
                 node.kind === 227 /* ExportAssignment */ ||
-                (node.flags & 2 /* Ambient */) ||
-                (node.flags & (1 /* Export */ | 1024 /* Default */))) {
+                (node.flags & 4 /* Ambient */) ||
+                (node.flags & (2 /* Export */ | 512 /* Default */))) {
                 return false;
             }
             return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
@@ -27739,7 +28189,7 @@ var ts;
         }
         function checkGrammarNumericLiteral(node) {
             // Grammar checking
-            if (node.flags & 65536 /* OctalLiteral */ && languageVersion >= 1 /* ES5 */) {
+            if (node.flags & 32768 /* OctalLiteral */ && languageVersion >= 1 /* ES5 */) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
             }
         }
@@ -27793,7 +28243,7 @@ var ts;
                 ts.forEach(root.referencedFiles, function (fileReference) {
                     var referencedFile = ts.tryResolveScriptReference(host, root, fileReference);
                     // All the references that are not going to be part of same file
-                    if (referencedFile && ((referencedFile.flags & 8192 /* DeclarationFile */) ||
+                    if (referencedFile && ((referencedFile.flags & 4096 /* DeclarationFile */) ||
                         ts.shouldEmitToOwnFile(referencedFile, compilerOptions) ||
                         !addedGlobalFileReference)) {
                         writeReferencePath(referencedFile);
@@ -27988,15 +28438,15 @@ var ts;
             }
         }
         function emitLines(nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                var node = nodes_2[_i];
                 emit(node);
             }
         }
         function emitSeparatedList(nodes, separator, eachNodeEmitFn, canEmitFn) {
             var currentWriterPos = writer.getTextPos();
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+                var node = nodes_3[_i];
                 if (!canEmitFn || canEmitFn(node)) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         write(separator);
@@ -28142,6 +28592,7 @@ var ts;
         function emitSourceFile(node) {
             currentSourceFile = node;
             enclosingDeclaration = node;
+            ts.emitDetachedComments(currentSourceFile, writer, ts.writeCommentRange, node, newLine, true /* remove comments */);
             emitLines(node.statements);
         }
         // Return a temp variable name to be used in `export default` statements.
@@ -28258,10 +28709,10 @@ var ts;
             // If the node is parented in the current source file we need to emit export declare or just export
             if (node.parent === currentSourceFile) {
                 // If the node is exported
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     write("export ");
                 }
-                if (node.flags & 1024 /* Default */) {
+                if (node.flags & 512 /* Default */) {
                     write("default ");
                 }
                 else if (node.kind !== 215 /* InterfaceDeclaration */) {
@@ -28270,16 +28721,16 @@ var ts;
             }
         }
         function emitClassMemberDeclarationFlags(node) {
-            if (node.flags & 32 /* Private */) {
+            if (node.flags & 16 /* Private */) {
                 write("private ");
             }
-            else if (node.flags & 64 /* Protected */) {
+            else if (node.flags & 32 /* Protected */) {
                 write("protected ");
             }
-            if (node.flags & 128 /* Static */) {
+            if (node.flags & 64 /* Static */) {
                 write("static ");
             }
-            if (node.flags & 256 /* Abstract */) {
+            if (node.flags & 128 /* Abstract */) {
                 write("abstract ");
             }
         }
@@ -28287,7 +28738,7 @@ var ts;
             // note usage of writer. methods instead of aliases created, just to make sure we are using
             // correct writer especially to handle asynchronous alias writing
             emitJsDocComments(node);
-            if (node.flags & 1 /* Export */) {
+            if (node.flags & 2 /* Export */) {
                 write("export ");
             }
             write("import ");
@@ -28322,12 +28773,12 @@ var ts;
             }
         }
         function writeImportDeclaration(node) {
-            if (!node.importClause && !(node.flags & 1 /* Export */)) {
+            if (!node.importClause && !(node.flags & 2 /* Export */)) {
                 // do not write non-exported import declarations that don't have import clauses
                 return;
             }
             emitJsDocComments(node);
-            if (node.flags & 1 /* Export */) {
+            if (node.flags & 2 /* Export */) {
                 write("export ");
             }
             write("import ");
@@ -28392,7 +28843,7 @@ var ts;
         function writeModuleDeclaration(node) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 131072 /* Namespace */) {
+            if (node.flags & 65536 /* Namespace */) {
                 write("namespace ");
             }
             else {
@@ -28464,7 +28915,7 @@ var ts;
             writeLine();
         }
         function isPrivateMethodTypeParameter(node) {
-            return node.parent.kind === 143 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */);
+            return node.parent.kind === 143 /* MethodDeclaration */ && (node.parent.flags & 16 /* Private */);
         }
         function emitTypeParameters(typeParameters) {
             function emitTypeParameter(node) {
@@ -28508,7 +28959,7 @@ var ts;
                             break;
                         case 143 /* MethodDeclaration */:
                         case 142 /* MethodSignature */:
-                            if (node.parent.flags & 128 /* Static */) {
+                            if (node.parent.flags & 64 /* Static */) {
                                 diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                             }
                             else if (node.parent.parent.kind === 214 /* ClassDeclaration */) {
@@ -28574,7 +29025,7 @@ var ts;
             function emitParameterProperties(constructorDeclaration) {
                 if (constructorDeclaration) {
                     ts.forEach(constructorDeclaration.parameters, function (param) {
-                        if (param.flags & 112 /* AccessibilityModifier */) {
+                        if (param.flags & 56 /* AccessibilityModifier */) {
                             emitPropertyDeclaration(param);
                         }
                     });
@@ -28582,7 +29033,7 @@ var ts;
             }
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 256 /* Abstract */) {
+            if (node.flags & 128 /* Abstract */) {
                 write("abstract ");
             }
             write("class ");
@@ -28652,7 +29103,7 @@ var ts;
                     if ((node.kind === 141 /* PropertyDeclaration */ || node.kind === 140 /* PropertySignature */) && node.parent.kind === 155 /* TypeLiteral */) {
                         emitTypeOfVariableDeclarationFromTypeLiteral(node);
                     }
-                    else if (!(node.flags & 32 /* Private */)) {
+                    else if (!(node.flags & 16 /* Private */)) {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
@@ -28667,7 +29118,7 @@ var ts;
                 }
                 else if (node.kind === 141 /* PropertyDeclaration */ || node.kind === 140 /* PropertySignature */) {
                     // TODO(jfreeman): Deal with computed properties in error reporting.
-                    if (node.flags & 128 /* Static */) {
+                    if (node.flags & 64 /* Static */) {
                         return symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                 ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -28771,7 +29222,7 @@ var ts;
                 emitJsDocComments(accessors.setAccessor);
                 emitClassMemberDeclarationFlags(node);
                 writeTextOfNode(currentSourceFile, node.name);
-                if (!(node.flags & 32 /* Private */)) {
+                if (!(node.flags & 16 /* Private */)) {
                     accessorWithTypeAnnotation = node;
                     var type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
@@ -28800,7 +29251,7 @@ var ts;
                 var diagnosticMessage;
                 if (accessorWithTypeAnnotation.kind === 146 /* SetAccessor */) {
                     // Setters have to have type named and cannot infer it so, the type should always be named
-                    if (accessorWithTypeAnnotation.parent.flags & 128 /* Static */) {
+                    if (accessorWithTypeAnnotation.parent.flags & 64 /* Static */) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
@@ -28818,7 +29269,7 @@ var ts;
                     };
                 }
                 else {
-                    if (accessorWithTypeAnnotation.flags & 128 /* Static */) {
+                    if (accessorWithTypeAnnotation.flags & 64 /* Static */) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                 ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -28905,7 +29356,7 @@ var ts;
                     emitType(node.type);
                 }
             }
-            else if (node.kind !== 144 /* Constructor */ && !(node.flags & 32 /* Private */)) {
+            else if (node.kind !== 144 /* Constructor */ && !(node.flags & 16 /* Private */)) {
                 writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
             }
             enclosingDeclaration = prevEnclosingDeclaration;
@@ -28936,7 +29387,7 @@ var ts;
                         break;
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
-                        if (node.flags & 128 /* Static */) {
+                        if (node.flags & 64 /* Static */) {
                             diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                     ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -28997,7 +29448,7 @@ var ts;
                 node.parent.parent.kind === 155 /* TypeLiteral */) {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
-            else if (!(node.parent.flags & 32 /* Private */)) {
+            else if (!(node.parent.flags & 16 /* Private */)) {
                 writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
             }
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) {
@@ -29028,7 +29479,7 @@ var ts;
                             ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
-                        if (node.parent.flags & 128 /* Static */) {
+                        if (node.parent.flags & 64 /* Static */) {
                             return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                     ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -29170,7 +29621,7 @@ var ts;
             }
         }
         function writeReferencePath(referencedFile) {
-            var declFileName = referencedFile.flags & 8192 /* DeclarationFile */
+            var declFileName = referencedFile.flags & 4096 /* DeclarationFile */
                 ? referencedFile.fileName // Declaration file, use declaration file name
                 : ts.shouldEmitToOwnFile(referencedFile, compilerOptions)
                     ? ts.getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file
@@ -29216,6 +29667,12 @@ var ts;
         return ts.isExternalModule(sourceFile) || ts.isDeclarationFile(sourceFile);
     }
     ts.isExternalModuleOrDeclarationFile = isExternalModuleOrDeclarationFile;
+    var Jump;
+    (function (Jump) {
+        Jump[Jump["Break"] = 2] = "Break";
+        Jump[Jump["Continue"] = 4] = "Continue";
+        Jump[Jump["Return"] = 8] = "Return";
+    })(Jump || (Jump = {}));
     var entities = {
         "quot": 0x0022,
         "amp": 0x0026,
@@ -29525,16 +29982,8 @@ var ts;
             diagnostics: diagnostics,
             sourceMaps: sourceMapDataList
         };
-        function isNodeDescendentOf(node, ancestor) {
-            while (node) {
-                if (node === ancestor)
-                    return true;
-                node = node.parent;
-            }
-            return false;
-        }
         function isUniqueLocalName(name, container) {
-            for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {
+            for (var node = container; ts.isNodeDescendentOf(node, container); node = node.nextContainer) {
                 if (node.locals && ts.hasProperty(node.locals, name)) {
                     // We conservatively include alias symbols to cover cases where they're emitted as locals
                     if (node.locals[name].flags & (107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */)) {
@@ -29544,12 +29993,6 @@ var ts;
             }
             return true;
         }
-        var Jump;
-        (function (Jump) {
-            Jump[Jump["Break"] = 2] = "Break";
-            Jump[Jump["Continue"] = 4] = "Continue";
-            Jump[Jump["Return"] = 8] = "Return";
-        })(Jump || (Jump = {}));
         function setLabeledJump(state, isBreak, labelText, labelMarker) {
             if (isBreak) {
                 if (!state.labeledNonLocalBreaks) {
@@ -31026,7 +31469,7 @@ var ts;
                     write("]");
                 }
                 else {
-                    emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/ (node.flags & 2048 /* MultiLine */) !== 0, 
+                    emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/ (node.flags & 1024 /* MultiLine */) !== 0, 
                     /*trailingComma*/ elements.hasTrailingComma, /*useConcat*/ true);
                 }
             }
@@ -31045,7 +31488,7 @@ var ts;
                         emitLinePreservingList(node, properties, /* allowTrailingComma */ languageVersion >= 1 /* ES5 */, /* spacesBetweenBraces */ true);
                     }
                     else {
-                        var multiLine = (node.flags & 2048 /* MultiLine */) !== 0;
+                        var multiLine = (node.flags & 1024 /* MultiLine */) !== 0;
                         if (!multiLine) {
                             write(" ");
                         }
@@ -31064,7 +31507,7 @@ var ts;
                 write("}");
             }
             function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) {
-                var multiLine = (node.flags & 2048 /* MultiLine */) !== 0;
+                var multiLine = (node.flags & 1024 /* MultiLine */) !== 0;
                 var properties = node.properties;
                 write("(");
                 if (multiLine) {
@@ -31693,7 +32136,7 @@ var ts;
                 var current = node;
                 while (current) {
                     if (current.kind === 248 /* SourceFile */) {
-                        return !isExported || ((ts.getCombinedNodeFlags(node) & 1 /* Export */) !== 0);
+                        return !isExported || ((ts.getCombinedNodeFlags(node) & 2 /* Export */) !== 0);
                     }
                     else if (ts.isFunctionLike(current) || current.kind === 219 /* ModuleBlock */) {
                         return false;
@@ -31934,7 +32377,7 @@ var ts;
                     // variables in variable declaration list were already hoisted
                     return false;
                 }
-                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 49152 /* BlockScoped */) === 0) {
+                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 24576 /* BlockScoped */) === 0) {
                     // we are inside a converted loop - this can only happen in downlevel scenarios 
                     // record names for all variable declarations
                     for (var _a = 0, _b = decl.declarations; _a < _b.length; _a++) {
@@ -32019,7 +32462,7 @@ var ts;
                         break;
                 }
                 var loopParameters;
-                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 49152 /* BlockScoped */)) {
+                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 24576 /* BlockScoped */)) {
                     // if loop initializer contains block scoped variables - they should be passed to converted loop body as parameters
                     loopParameters = [];
                     for (var _a = 0, _b = loopInitializer.declarations; _a < _b.length; _a++) {
@@ -32334,10 +32777,12 @@ var ts;
                 //
                 //     for (let v of arr) { }
                 //
-                // we don't want to emit a temporary variable for the RHS, just use it directly.
-                var rhsIsIdentifier = node.expression.kind === 69 /* Identifier */;
+                // we can't reuse 'arr' because it might be modified within the body of the loop.
                 var counter = createTempVariable(268435456 /* _i */);
-                var rhsReference = rhsIsIdentifier ? node.expression : createTempVariable(0 /* Auto */);
+                var rhsReference = ts.createSynthesizedNode(69 /* Identifier */);
+                rhsReference.text = node.expression.kind === 69 /* Identifier */ ?
+                    makeUniqueName(node.expression.text) :
+                    makeTempVariableName(0 /* Auto */);
                 // This is the let keyword for the counter and rhsReference. The let keyword for
                 // the LHS will be emitted inside the body.
                 emitStart(node.expression);
@@ -32346,15 +32791,13 @@ var ts;
                 emitNodeWithoutSourceMap(counter);
                 write(" = 0");
                 emitEnd(node.expression);
-                if (!rhsIsIdentifier) {
-                    // , _a = expr
-                    write(", ");
-                    emitStart(node.expression);
-                    emitNodeWithoutSourceMap(rhsReference);
-                    write(" = ");
-                    emitNodeWithoutSourceMap(node.expression);
-                    emitEnd(node.expression);
-                }
+                // , _a = expr
+                write(", ");
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(rhsReference);
+                write(" = ");
+                emitNodeWithoutSourceMap(node.expression);
+                emitEnd(node.expression);
                 write("; ");
                 // _i < _a.length;
                 emitStart(node.initializer);
@@ -32609,7 +33052,7 @@ var ts;
             }
             function emitModuleMemberName(node) {
                 emitStart(node.name);
-                if (ts.getCombinedNodeFlags(node) & 1 /* Export */) {
+                if (ts.getCombinedNodeFlags(node) & 2 /* Export */) {
                     var container = getContainingModule(node);
                     if (container) {
                         write(getGeneratedNameForNode(container));
@@ -32631,7 +33074,7 @@ var ts;
             }
             function emitEs6ExportDefaultCompat(node) {
                 if (node.parent.kind === 248 /* SourceFile */) {
-                    ts.Debug.assert(!!(node.flags & 1024 /* Default */) || node.kind === 227 /* ExportAssignment */);
+                    ts.Debug.assert(!!(node.flags & 512 /* Default */) || node.kind === 227 /* ExportAssignment */);
                     // only allow export default at a source file level
                     if (modulekind === 1 /* CommonJS */ || modulekind === 2 /* AMD */ || modulekind === 3 /* UMD */) {
                         if (!currentSourceFile.symbol.exports["___esModule"]) {
@@ -32649,7 +33092,7 @@ var ts;
                 }
             }
             function emitExportMemberAssignment(node) {
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     writeLine();
                     emitStart(node);
                     // emit call to exporter only for top level nodes
@@ -32657,7 +33100,7 @@ var ts;
                         // emit export default <smth> as
                         // export("default", <smth>)
                         write(exportFunctionForFile + "(\"");
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             write("default");
                         }
                         else {
@@ -32668,7 +33111,7 @@ var ts;
                         write(")");
                     }
                     else {
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             emitEs6ExportDefaultCompat(node);
                             if (languageVersion === 0 /* ES3 */) {
                                 write("exports[\"default\"]");
@@ -32772,7 +33215,7 @@ var ts;
                 // because actual variable declarations are hoisted
                 var canDefineTempVariablesInPlace = false;
                 if (root.kind === 211 /* VariableDeclaration */) {
-                    var isExported = ts.getCombinedNodeFlags(root) & 1 /* Export */;
+                    var isExported = ts.getCombinedNodeFlags(root) & 2 /* Export */;
                     var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
                     canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind;
                 }
@@ -32854,8 +33297,8 @@ var ts;
                         // to ensure value is evaluated exactly once.
                         value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     }
-                    for (var _a = 0; _a < properties.length; _a++) {
-                        var p = properties[_a];
+                    for (var _a = 0, properties_5 = properties; _a < properties_5.length; _a++) {
+                        var p = properties_5[_a];
                         if (p.kind === 245 /* PropertyAssignment */ || p.kind === 246 /* ShorthandPropertyAssignment */) {
                             var propName = p.name;
                             var target_1 = p.kind === 246 /* ShorthandPropertyAssignment */ ? p : p.initializer || propName;
@@ -32990,7 +33433,7 @@ var ts;
                         // this is necessary to preserve ES6 semantic in scenarios like
                         // for (...) { let x; console.log(x); x = 1 } // assignment on one iteration should not affect other iterations
                         var isLetDefinedInLoop = (resolver.getNodeCheckFlags(node) & 16384 /* BlockScopedBindingInLoop */) &&
-                            (getCombinedFlagsForIdentifier(node.name) & 16384 /* Let */);
+                            (getCombinedFlagsForIdentifier(node.name) & 8192 /* Let */);
                         // NOTE: default initialization should not be added to let bindings in for-in\for-of statements
                         if (isLetDefinedInLoop &&
                             node.parent.parent.kind !== 200 /* ForInStatement */ &&
@@ -33030,13 +33473,13 @@ var ts;
                 return ts.getCombinedNodeFlags(node.parent);
             }
             function isES6ExportedDeclaration(node) {
-                return !!(node.flags & 1 /* Export */) &&
+                return !!(node.flags & 2 /* Export */) &&
                     modulekind === 5 /* ES6 */ &&
                     node.parent.kind === 248 /* SourceFile */;
             }
             function emitVariableStatement(node) {
                 var startIsEmitted = false;
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     if (isES6ExportedDeclaration(node)) {
                         // Exported ES6 module member
                         write("export ");
@@ -33063,7 +33506,7 @@ var ts;
             function shouldEmitLeadingAndTrailingCommentsForVariableStatement(node) {
                 // If we're not exporting the variables, there's nothing special here.
                 // Always emit comments for these nodes.
-                if (!(node.flags & 1 /* Export */)) {
+                if (!(node.flags & 2 /* Export */)) {
                     return true;
                 }
                 // If we are exporting, but it's a top-level ES6 module exports,
@@ -33246,7 +33689,7 @@ var ts;
                 if (!shouldEmitAsArrowFunction(node)) {
                     if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             write("default ");
                         }
                     }
@@ -33466,7 +33909,7 @@ var ts;
                 emitRestParameter(node);
             }
             function emitExpressionFunctionBody(node, body) {
-                if (languageVersion < 2 /* ES6 */ || node.flags & 512 /* Async */) {
+                if (languageVersion < 2 /* ES6 */ || node.flags & 256 /* Async */) {
                     emitDownLevelExpressionFunctionBody(node, body);
                     return;
                 }
@@ -33487,7 +33930,7 @@ var ts;
                 scopeEmitStart(node);
                 increaseIndent();
                 var outPos = writer.getTextPos();
-                emitDetachedComments(node.body);
+                emitDetachedCommentsAndUpdateCommentsInfo(node.body);
                 emitFunctionBodyPreamble(node);
                 var preambleEmitted = writer.getTextPos() !== outPos;
                 decreaseIndent();
@@ -33525,7 +33968,7 @@ var ts;
                 scopeEmitStart(node);
                 var initialTextPos = writer.getTextPos();
                 increaseIndent();
-                emitDetachedComments(body.statements);
+                emitDetachedCommentsAndUpdateCommentsInfo(body.statements);
                 // Emit all the directive prologues (like "use strict").  These have to come before
                 // any other preamble code we write (like parameter initializers).
                 var startIndex = emitDirectivePrologues(body.statements, /*startWithNewLine*/ true);
@@ -33569,7 +34012,7 @@ var ts;
             }
             function emitParameterPropertyAssignments(node) {
                 ts.forEach(node.parameters, function (param) {
-                    if (param.flags & 112 /* AccessibilityModifier */) {
+                    if (param.flags & 56 /* AccessibilityModifier */) {
                         writeLine();
                         emitStart(param);
                         emitStart(param.name);
@@ -33604,15 +34047,15 @@ var ts;
                 var properties = [];
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
-                    if (member.kind === 141 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) {
+                    if (member.kind === 141 /* PropertyDeclaration */ && isStatic === ((member.flags & 64 /* Static */) !== 0) && member.initializer) {
                         properties.push(member);
                     }
                 }
                 return properties;
             }
             function emitPropertyDeclarations(node, properties) {
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var property = properties[_a];
+                for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
+                    var property = properties_6[_a];
                     emitPropertyDeclaration(node, property);
                 }
             }
@@ -33625,7 +34068,7 @@ var ts;
                     emit(receiver);
                 }
                 else {
-                    if (property.flags & 128 /* Static */) {
+                    if (property.flags & 64 /* Static */) {
                         emitDeclarationName(node);
                     }
                     else {
@@ -33724,7 +34167,7 @@ var ts;
                         writeLine();
                         emitLeadingComments(member);
                         emitStart(member);
-                        if (member.flags & 128 /* Static */) {
+                        if (member.flags & 64 /* Static */) {
                             write("static ");
                         }
                         if (member.kind === 145 /* GetAccessor */) {
@@ -33774,7 +34217,7 @@ var ts;
                         emitCommentsOnNotEmittedNode(member);
                     }
                     // Check if there is any non-static property assignment
-                    if (member.kind === 141 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) {
+                    if (member.kind === 141 /* PropertyDeclaration */ && member.initializer && (member.flags & 64 /* Static */) === 0) {
                         hasInstancePropertyWithInitializer = true;
                     }
                 });
@@ -33821,7 +34264,7 @@ var ts;
                     // Emit all the directive prologues (like "use strict").  These have to come before
                     // any other preamble code we write (like parameter initializers).
                     startIndex = emitDirectivePrologues(ctor.body.statements, /*startWithNewLine*/ true);
-                    emitDetachedComments(ctor.body.statements);
+                    emitDetachedCommentsAndUpdateCommentsInfo(ctor.body.statements);
                 }
                 emitCaptureThisForNodeIfNecessary(node);
                 var superCall;
@@ -33941,7 +34384,7 @@ var ts;
                         //     _default = __decorate([dec], _default);
                         //     export default _default;
                         //
-                        if (isES6ExportedDeclaration(node) && !(node.flags & 1024 /* Default */)) {
+                        if (isES6ExportedDeclaration(node) && !(node.flags & 512 /* Default */)) {
                             write("export ");
                         }
                         write("let ");
@@ -33950,7 +34393,7 @@ var ts;
                     }
                     else if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             write("default ");
                         }
                     }
@@ -33980,7 +34423,7 @@ var ts;
                 // emit name if
                 // - node has a name
                 // - this is default export with static initializers
-                if ((node.name || (node.flags & 1024 /* Default */ && staticProperties.length > 0)) && !thisNodeIsDecorated) {
+                if ((node.name || (node.flags & 512 /* Default */ && staticProperties.length > 0)) && !thisNodeIsDecorated) {
                     write(" ");
                     emitDeclarationName(node);
                 }
@@ -34016,8 +34459,8 @@ var ts;
                 //      HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using
                 //                                  a lexical declaration such as a LexicalDeclaration or a ClassDeclaration.
                 if (isClassExpressionWithStaticProperties) {
-                    for (var _a = 0; _a < staticProperties.length; _a++) {
-                        var property = staticProperties[_a];
+                    for (var _a = 0, staticProperties_1 = staticProperties; _a < staticProperties_1.length; _a++) {
+                        var property = staticProperties_1[_a];
                         write(",");
                         writeLine();
                         emitPropertyDeclaration(node, property, /*receiver:*/ tempVariable, /*isExpression:*/ true);
@@ -34035,7 +34478,7 @@ var ts;
                 }
                 // If this is an exported class, but not on the top level (i.e. on an internal
                 // module), export it
-                if (!isES6ExportedDeclaration(node) && (node.flags & 1 /* Export */)) {
+                if (!isES6ExportedDeclaration(node) && (node.flags & 2 /* Export */)) {
                     writeLine();
                     emitStart(node);
                     emitModuleMemberName(node);
@@ -34044,7 +34487,7 @@ var ts;
                     emitEnd(node);
                     write(";");
                 }
-                else if (isES6ExportedDeclaration(node) && (node.flags & 1024 /* Default */) && thisNodeIsDecorated) {
+                else if (isES6ExportedDeclaration(node) && (node.flags & 512 /* Default */) && thisNodeIsDecorated) {
                     // if this is a top level default export of decorated class, write the export after the declaration.
                     writeLine();
                     write("export default ");
@@ -34126,13 +34569,13 @@ var ts;
             }
             function emitClassMemberPrefix(node, member) {
                 emitDeclarationName(node);
-                if (!(member.flags & 128 /* Static */)) {
+                if (!(member.flags & 64 /* Static */)) {
                     write(".prototype");
                 }
             }
             function emitDecoratorsOfClass(node) {
                 emitDecoratorsOfMembers(node, /*staticFlag*/ 0);
-                emitDecoratorsOfMembers(node, 128 /* Static */);
+                emitDecoratorsOfMembers(node, 64 /* Static */);
                 emitDecoratorsOfConstructor(node);
             }
             function emitDecoratorsOfConstructor(node) {
@@ -34179,7 +34622,7 @@ var ts;
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
                     // only emit members in the correct group
-                    if ((member.flags & 128 /* Static */) !== staticFlag) {
+                    if ((member.flags & 64 /* Static */) !== staticFlag) {
                         continue;
                     }
                     // skip members that cannot be decorated (such as the constructor)
@@ -34580,7 +35023,7 @@ var ts;
                 }
                 if (!shouldHoistDeclarationInSystemJsModule(node)) {
                     // do not emit var if variable was already hoisted
-                    if (!(node.flags & 1 /* Export */) || isES6ExportedDeclaration(node)) {
+                    if (!(node.flags & 2 /* Export */) || isES6ExportedDeclaration(node)) {
                         emitStart(node);
                         if (isES6ExportedDeclaration(node)) {
                             write("export ");
@@ -34611,7 +35054,7 @@ var ts;
                 emitModuleMemberName(node);
                 write(" = {}));");
                 emitEnd(node);
-                if (!isES6ExportedDeclaration(node) && node.flags & 1 /* Export */ && !shouldHoistDeclarationInSystemJsModule(node)) {
+                if (!isES6ExportedDeclaration(node) && node.flags & 2 /* Export */ && !shouldHoistDeclarationInSystemJsModule(node)) {
                     // do not emit var if variable was already hoisted
                     writeLine();
                     emitStart(node);
@@ -34623,7 +35066,7 @@ var ts;
                     write(";");
                 }
                 if (modulekind !== 5 /* ES6 */ && node.parent === currentSourceFile) {
-                    if (modulekind === 4 /* System */ && (node.flags & 1 /* Export */)) {
+                    if (modulekind === 4 /* System */ && (node.flags & 2 /* Export */)) {
                         // write the call to exporter for enum
                         writeLine();
                         write(exportFunctionForFile + "(\"");
@@ -34728,7 +35171,7 @@ var ts;
                 }
                 write(")(");
                 // write moduleDecl = containingModule.m only if it is not exported es6 module member
-                if ((node.flags & 1 /* Export */) && !isES6ExportedDeclaration(node)) {
+                if ((node.flags & 2 /* Export */) && !isES6ExportedDeclaration(node)) {
                     emit(node.name);
                     write(" = ");
                 }
@@ -34738,7 +35181,7 @@ var ts;
                 write(" = {}));");
                 emitEnd(node);
                 if (!isES6ExportedDeclaration(node) && node.name.kind === 69 /* Identifier */ && node.parent === currentSourceFile) {
-                    if (modulekind === 4 /* System */ && (node.flags & 1 /* Export */)) {
+                    if (modulekind === 4 /* System */ && (node.flags & 2 /* Export */)) {
                         writeLine();
                         write(exportFunctionForFile + "(\"");
                         emitDeclarationName(node);
@@ -34841,7 +35284,7 @@ var ts;
             }
             function emitExternalImportDeclaration(node) {
                 if (ts.contains(externalImports, node)) {
-                    var isExportedImport = node.kind === 221 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0;
+                    var isExportedImport = node.kind === 221 /* ImportEqualsDeclaration */ && (node.flags & 2 /* Export */) !== 0;
                     var namespaceDeclaration = getNamespaceDeclarationNode(node);
                     if (modulekind !== 2 /* AMD */) {
                         emitLeadingComments(node);
@@ -34923,7 +35366,7 @@ var ts;
                             write("export ");
                             write("var ");
                         }
-                        else if (!(node.flags & 1 /* Export */)) {
+                        else if (!(node.flags & 2 /* Export */)) {
                             write("var ");
                         }
                     }
@@ -35014,8 +35457,8 @@ var ts;
             function emitExportOrImportSpecifierList(specifiers, shouldEmit) {
                 ts.Debug.assert(modulekind === 5 /* ES6 */);
                 var needsComma = false;
-                for (var _a = 0; _a < specifiers.length; _a++) {
-                    var specifier = specifiers[_a];
+                for (var _a = 0, specifiers_1 = specifiers; _a < specifiers_1.length; _a++) {
+                    var specifier = specifiers_1[_a];
                     if (shouldEmit(specifier)) {
                         if (needsComma) {
                             write(", ");
@@ -35158,8 +35601,8 @@ var ts;
                 }
                 writeLine();
                 var started = false;
-                for (var _a = 0; _a < externalImports.length; _a++) {
-                    var importNode = externalImports[_a];
+                for (var _a = 0, externalImports_1 = externalImports; _a < externalImports_1.length; _a++) {
+                    var importNode = externalImports_1[_a];
                     // do not create variable declaration for exports and imports that lack import clause
                     var skipNode = importNode.kind === 228 /* ExportDeclaration */ ||
                         (importNode.kind === 222 /* ImportDeclaration */ && !importNode.importClause);
@@ -35193,8 +35636,8 @@ var ts;
                     // no exported declarations (export var ...) or export specifiers (export {x})
                     // check if we have any non star export declarations.
                     var hasExportDeclarationWithExportClause = false;
-                    for (var _a = 0; _a < externalImports.length; _a++) {
-                        var externalImport = externalImports[_a];
+                    for (var _a = 0, externalImports_2 = externalImports; _a < externalImports_2.length; _a++) {
+                        var externalImport = externalImports_2[_a];
                         if (externalImport.kind === 228 /* ExportDeclaration */ && externalImport.exportClause) {
                             hasExportDeclarationWithExportClause = true;
                             break;
@@ -35225,8 +35668,8 @@ var ts;
                         }
                     }
                 }
-                for (var _d = 0; _d < externalImports.length; _d++) {
-                    var externalImport = externalImports[_d];
+                for (var _d = 0, externalImports_3 = externalImports; _d < externalImports_3.length; _d++) {
+                    var externalImport = externalImports_3[_d];
                     if (externalImport.kind !== 228 /* ExportDeclaration */) {
                         continue;
                     }
@@ -35275,7 +35718,7 @@ var ts;
                 function writeExportedName(node) {
                     // do not record default exports
                     // they are local to module and never overwritten (explicitly skipped) by star export
-                    if (node.kind !== 69 /* Identifier */ && node.flags & 1024 /* Default */) {
+                    if (node.kind !== 69 /* Identifier */ && node.flags & 512 /* Default */) {
                         return;
                     }
                     if (started) {
@@ -35338,7 +35781,7 @@ var ts;
                             emit(local);
                         }
                         var flags = ts.getCombinedNodeFlags(local.kind === 69 /* Identifier */ ? local.parent : local);
-                        if (flags & 1 /* Export */) {
+                        if (flags & 2 /* Export */) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -35348,11 +35791,11 @@ var ts;
                     write(";");
                 }
                 if (hoistedFunctionDeclarations) {
-                    for (var _a = 0; _a < hoistedFunctionDeclarations.length; _a++) {
-                        var f = hoistedFunctionDeclarations[_a];
+                    for (var _a = 0, hoistedFunctionDeclarations_1 = hoistedFunctionDeclarations; _a < hoistedFunctionDeclarations_1.length; _a++) {
+                        var f = hoistedFunctionDeclarations_1[_a];
                         writeLine();
                         emit(f);
-                        if (f.flags & 1 /* Export */) {
+                        if (f.flags & 2 /* Export */) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -35362,7 +35805,7 @@ var ts;
                 }
                 return exportedDeclarations;
                 function visit(node) {
-                    if (node.flags & 2 /* Ambient */) {
+                    if (node.flags & 4 /* Ambient */) {
                         return;
                     }
                     if (node.kind === 213 /* FunctionDeclaration */) {
@@ -35437,7 +35880,7 @@ var ts;
                 // - it is top level block scoped
                 // if block scoped variables are nested in some another block then
                 // no other functions can use them except ones that are defined at least in the same block
-                return (ts.getCombinedNodeFlags(node) & 49152 /* BlockScoped */) === 0 ||
+                return (ts.getCombinedNodeFlags(node) & 24576 /* BlockScoped */) === 0 ||
                     ts.getEnclosingBlockScopeContainer(node).kind === 248 /* SourceFile */;
             }
             function isCurrentFileSystemExternalModule() {
@@ -35509,8 +35952,8 @@ var ts;
                     var parameterName = makeUniqueName(ts.forEach(group, getLocalNameForExternalImport) || "");
                     write("function (" + parameterName + ") {");
                     increaseIndent();
-                    for (var _a = 0; _a < group.length; _a++) {
-                        var entry = group[_a];
+                    for (var _a = 0, group_1 = group; _a < group_1.length; _a++) {
+                        var entry = group_1[_a];
                         var importVariableName = getLocalNameForExternalImport(entry) || "";
                         switch (entry.kind) {
                             case 222 /* ImportDeclaration */:
@@ -35679,8 +36122,8 @@ var ts;
                         unaliasedModuleNames.push("\"" + amdDependency.path + "\"");
                     }
                 }
-                for (var _c = 0; _c < externalImports.length; _c++) {
-                    var importNode = externalImports[_c];
+                for (var _c = 0, externalImports_4 = externalImports; _c < externalImports_4.length; _c++) {
+                    var importNode = externalImports_4[_c];
                     // Find the name of the external module
                     var externalModuleName = getExternalModuleNameText(importNode);
                     // Find the name of the module alias, if there is one
@@ -35959,7 +36402,7 @@ var ts;
                 // Start new file on new line
                 writeLine();
                 emitShebang();
-                emitDetachedComments(node);
+                emitDetachedCommentsAndUpdateCommentsInfo(node);
                 if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
                     var emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[1 /* CommonJS */];
                     emitModule(node);
@@ -35983,7 +36426,7 @@ var ts;
             }
             function emitNodeConsideringCommentsOption(node, emitNodeConsideringSourcemap) {
                 if (node) {
-                    if (node.flags & 2 /* Ambient */) {
+                    if (node.flags & 4 /* Ambient */) {
                         return emitCommentsOnNotEmittedNode(node);
                     }
                     if (isSpecializedCommentHandling(node)) {
@@ -36232,10 +36675,6 @@ var ts;
                 }
                 return leadingComments;
             }
-            function isPinnedComments(comment) {
-                return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
-                    currentSourceFile.text.charCodeAt(comment.pos + 2) === 33 /* exclamation */;
-            }
             /**
              * Determine if the given comment is a triple-slash
              *
@@ -36350,57 +36789,14 @@ var ts;
                 // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
                 ts.emitComments(currentSourceFile, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
             }
-            function emitDetachedComments(node) {
-                var leadingComments;
-                if (compilerOptions.removeComments) {
-                    // removeComments is true, only reserve pinned comment at the top of file
-                    // For example:
-                    //      /*! Pinned Comment */
-                    //
-                    //      var x = 10;
-                    if (node.pos === 0) {
-                        leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComments);
+            function emitDetachedCommentsAndUpdateCommentsInfo(node) {
+                var currentDetachedCommentInfo = ts.emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, compilerOptions.removeComments);
+                if (currentDetachedCommentInfo) {
+                    if (detachedCommentsInfo) {
+                        detachedCommentsInfo.push(currentDetachedCommentInfo);
                     }
-                }
-                else {
-                    // removeComments is false, just get detached as normal and bypass the process to filter comment
-                    leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                }
-                if (leadingComments) {
-                    var detachedComments = [];
-                    var lastComment;
-                    ts.forEach(leadingComments, function (comment) {
-                        if (lastComment) {
-                            var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, lastComment.end);
-                            var commentLine = ts.getLineOfLocalPosition(currentSourceFile, comment.pos);
-                            if (commentLine >= lastCommentLine + 2) {
-                                // There was a blank line between the last comment and this comment.  This
-                                // comment is not part of the copyright comments.  Return what we have so
-                                // far.
-                                return detachedComments;
-                            }
-                        }
-                        detachedComments.push(comment);
-                        lastComment = comment;
-                    });
-                    if (detachedComments.length) {
-                        // All comments look like they could have been part of the copyright header.  Make
-                        // sure there is at least one blank line between it and the node.  If not, it's not
-                        // a copyright header.
-                        var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
-                        var nodeLine = ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
-                        if (nodeLine >= lastCommentLine + 2) {
-                            // Valid detachedComments
-                            ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
-                            ts.emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
-                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
-                            if (detachedCommentsInfo) {
-                                detachedCommentsInfo.push(currentDetachedCommentInfo);
-                            }
-                            else {
-                                detachedCommentsInfo = [currentDetachedCommentInfo];
-                            }
-                        }
+                    else {
+                        detachedCommentsInfo = [currentDetachedCommentInfo];
                     }
                 }
             }
@@ -36716,7 +37112,7 @@ var ts;
         var resolveModuleNamesWorker = host.resolveModuleNames
             ? (function (moduleNames, containingFile) { return host.resolveModuleNames(moduleNames, containingFile); })
             : (function (moduleNames, containingFile) { return ts.map(moduleNames, function (moduleName) { return resolveModuleName(moduleName, containingFile, options, host).resolvedModule; }); });
-        var filesByName = ts.createFileMap(getCanonicalFileName);
+        var filesByName = ts.createFileMap();
         // stores 'filename -> file association' ignoring case
         // used to track cases when two file names differ only in casing 
         var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createFileMap(function (fileName) { return fileName.toLowerCase(); }) : undefined;
@@ -36774,8 +37170,8 @@ var ts;
                 // Initialize a checker so that all our files are bound.
                 getTypeChecker();
                 classifiableNames = {};
-                for (var _i = 0; _i < files.length; _i++) {
-                    var sourceFile = files[_i];
+                for (var _i = 0, files_3 = files; _i < files_3.length; _i++) {
+                    var sourceFile = files_3[_i];
                     ts.copyMap(sourceFile.classifiableNames, classifiableNames);
                 }
             }
@@ -36793,7 +37189,7 @@ var ts;
             }
             // check if program source files has changed in the way that can affect structure of the program
             var newSourceFiles = [];
-            var normalizedAbsoluteFileNames = [];
+            var filePaths = [];
             var modifiedSourceFiles = [];
             for (var _i = 0, _a = oldProgram.getSourceFiles(); _i < _a.length; _i++) {
                 var oldSourceFile = _a[_i];
@@ -36801,8 +37197,8 @@ var ts;
                 if (!newSourceFile) {
                     return false;
                 }
-                var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);
-                normalizedAbsoluteFileNames.push(normalizedAbsolutePath);
+                newSourceFile.path = oldSourceFile.path;
+                filePaths.push(newSourceFile.path);
                 if (oldSourceFile !== newSourceFile) {
                     if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
                         // value of no-default-lib has changed
@@ -36822,7 +37218,7 @@ var ts;
                     }
                     if (resolveModuleNamesWorker) {
                         var moduleNames = ts.map(newSourceFile.imports, function (name) { return name.text; });
-                        var resolutions = resolveModuleNamesWorker(moduleNames, normalizedAbsolutePath);
+                        var resolutions = resolveModuleNamesWorker(moduleNames, ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));
                         // ensure that module resolution results are still correct
                         for (var i = 0; i < moduleNames.length; ++i) {
                             var newResolution = resolutions[i];
@@ -36850,12 +37246,12 @@ var ts;
             }
             // update fileName -> file mapping
             for (var i = 0, len = newSourceFiles.length; i < len; ++i) {
-                filesByName.set(normalizedAbsoluteFileNames[i], newSourceFiles[i]);
+                filesByName.set(filePaths[i], newSourceFiles[i]);
             }
             files = newSourceFiles;
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
-            for (var _b = 0; _b < modifiedSourceFiles.length; _b++) {
-                var modifiedFile = modifiedSourceFiles[_b];
+            for (var _b = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _b < modifiedSourceFiles_1.length; _b++) {
+                var modifiedFile = modifiedSourceFiles_1[_b];
                 fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);
             }
             oldProgram.structureIsReused = true;
@@ -36905,7 +37301,7 @@ var ts;
             return emitResult;
         }
         function getSourceFile(fileName) {
-            return filesByName.get(ts.getNormalizedAbsolutePath(fileName, currentDirectory));
+            return filesByName.get(ts.toPath(fileName, currentDirectory, getCanonicalFileName));
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) {
             if (sourceFile) {
@@ -37024,7 +37420,7 @@ var ts;
                         }
                         break;
                     case 218 /* ModuleDeclaration */:
-                        if (node.name.kind === 9 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) {
+                        if (node.name.kind === 9 /* StringLiteral */ && (node.flags & 4 /* Ambient */ || ts.isDeclarationFile(file))) {
                             // TypeScript 1.0 spec (April 2014): 12.1.6
                             // An AmbientExternalModuleDeclaration declares an external module. 
                             // This type of declaration is permitted only in the global module.
@@ -37049,7 +37445,7 @@ var ts;
                     diagnostic = ts.Diagnostics.File_0_has_unsupported_extension_The_only_supported_extensions_are_1;
                     diagnosticArgument = [fileName, "'" + ts.supportedExtensions.join("', '") + "'"];
                 }
-                else if (!findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd)) {
+                else if (!findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd)) {
                     diagnostic = ts.Diagnostics.File_0_not_found;
                     diagnosticArgument = [fileName];
                 }
@@ -37059,13 +37455,13 @@ var ts;
                 }
             }
             else {
-                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd);
+                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd);
                 if (!nonTsFile) {
                     if (options.allowNonTsExtensions) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         diagnosticArgument = [fileName];
                     }
-                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.getNormalizedAbsolutePath(fileName + extension, currentDirectory), isDefaultLib, refFile, refPos, refEnd); })) {
+                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.toPath(fileName + extension, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd); })) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         fileName += ".ts";
                         diagnosticArgument = [fileName];
@@ -37111,6 +37507,7 @@ var ts;
             });
             filesByName.set(normalizedAbsolutePath, file);
             if (file) {
+                file.path = normalizedAbsolutePath;
                 if (host.useCaseSensitiveFileNames()) {
                     // for case-sensitive file systems check if we've already seen some file with similar filename ignoring case
                     var existingFile = filesByNameIgnoreCase.get(normalizedAbsolutePath);
@@ -37157,13 +37554,7 @@ var ts;
                     var resolution = resolutions[i];
                     ts.setResolvedModule(file, moduleNames[i], resolution);
                     if (resolution && !options.noResolve) {
-                        var absoluteImportPath = ts.isRootedDiskPath(resolution.resolvedFileName)
-                            ? resolution.resolvedFileName
-                            : ts.getNormalizedAbsolutePath(resolution.resolvedFileName, currentDirectory);
-                        // convert an absolute import path to path that is relative to current directory
-                        // this was host still can locate it but files names in user output will be shorter (and thus look nicer).
-                        var relativePath = ts.getRelativePathToDirectoryOrUrl(currentDirectory, absoluteImportPath, currentDirectory, getCanonicalFileName, false);
-                        var importedFile = findSourceFile(relativePath, absoluteImportPath, /* isDefaultLib */ false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
+                        var importedFile = findSourceFile(resolution.resolvedFileName, ts.toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), /* isDefaultLib */ false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!ts.isExternalModule(importedFile)) {
                                 var start_2 = ts.getTokenPosOfNode(file.imports[i], file);
@@ -37219,8 +37610,8 @@ var ts;
             var allFilesBelongToPath = true;
             if (sourceFiles) {
                 var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) {
+                    var sourceFile = sourceFiles_1[_i];
                     if (!ts.isDeclarationFile(sourceFile)) {
                         var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
                         if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
@@ -37344,6 +37735,7 @@ var ts;
 /// <reference path="sys.ts"/>
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
+/// <reference path="diagnosticInformationMap.generated.ts"/>
 /// <reference path="scanner.ts"/>
 var ts;
 (function (ts) {
@@ -37493,6 +37885,12 @@ var ts;
             type: "boolean",
             description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
         },
+        {
+            name: "pretty",
+            paramType: ts.Diagnostics.KIND,
+            description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
         {
             name: "project",
             shortName: "p",
@@ -37591,11 +37989,31 @@ var ts;
             description: ts.Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
             error: ts.Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic
         },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
         {
             name: "forceConsistentCasingInFileNames",
             type: "boolean",
             description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
-        },
+        }
     ];
     var optionNameMapCache;
     /* @internal */
@@ -37734,13 +38152,38 @@ var ts;
       */
     function parseConfigFileTextToJson(fileName, jsonText) {
         try {
-            return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
+            var jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
         }
         catch (e) {
             return { error: ts.createCompilerDiagnostic(ts.Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
         }
     }
     ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
+    /**
+     * Remove the comments from a json like text.
+     * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
+     *
+     * This method replace comment content by whitespace rather than completely remove them to keep positions in json parsing error reporting accurate.
+     */
+    function removeComments(jsonText) {
+        var output = "";
+        var scanner = ts.createScanner(1 /* ES5 */, /* skipTrivia */ false, 0 /* Standard */, jsonText);
+        var token;
+        while ((token = scanner.scan()) !== 1 /* EndOfFileToken */) {
+            switch (token) {
+                case 2 /* SingleLineCommentTrivia */:
+                case 3 /* MultiLineCommentTrivia */:
+                    // replace comments with whitespace to preserve original character positions
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
     /**
       * Parse the contents of a config file (tsconfig.json).
       * @param json The contents of the config file to parse
@@ -37871,8 +38314,8 @@ var ts;
                     var lastSingleLineCommentEnd = -1;
                     var isFirstSingleLineComment = true;
                     var singleLineCommentCount = 0;
-                    for (var _i = 0; _i < comments.length; _i++) {
-                        var currentComment = comments[_i];
+                    for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) {
+                        var currentComment = comments_2[_i];
                         // For single line comments, combine consecutive ones (2 or more) into
                         // a single span from the start of the first till the end of the last
                         if (currentComment.kind === 2 /* SingleLineCommentTrivia */) {
@@ -38004,6 +38447,8 @@ var ts;
         function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) {
             var patternMatcher = ts.createPatternMatcher(searchValue);
             var rawItems = [];
+            // This means "compare in a case insensitive manner."
+            var baseSensitivity = { sensitivity: "base" };
             // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] 
             ts.forEach(program.getSourceFiles(), function (sourceFile) {
                 cancellationToken.throwIfCancellationRequested();
@@ -38017,8 +38462,8 @@ var ts;
                         if (!matches) {
                             continue;
                         }
-                        for (var _i = 0; _i < declarations.length; _i++) {
-                            var declaration = declarations[_i];
+                        for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                            var declaration = declarations_6[_i];
                             // It was a match!  If the pattern has dots in it, then also see if the 
                             // declaration container matches as well.
                             if (patternMatcher.patternContainsDots) {
@@ -38047,8 +38492,8 @@ var ts;
             function allMatchesAreCaseSensitive(matches) {
                 ts.Debug.assert(matches.length > 0);
                 // This is a case sensitive match, only if all the submatches were case sensitive.
-                for (var _i = 0; _i < matches.length; _i++) {
-                    var match = matches[_i];
+                for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
+                    var match = matches_1[_i];
                     if (!match.isCaseSensitive) {
                         return false;
                     }
@@ -38123,8 +38568,8 @@ var ts;
             function bestMatchKind(matches) {
                 ts.Debug.assert(matches.length > 0);
                 var bestMatchKind = ts.PatternMatchKind.camelCase;
-                for (var _i = 0; _i < matches.length; _i++) {
-                    var match = matches[_i];
+                for (var _i = 0, matches_2 = matches; _i < matches_2.length; _i++) {
+                    var match = matches_2[_i];
                     var kind = match.kind;
                     if (kind < bestMatchKind) {
                         bestMatchKind = kind;
@@ -38132,8 +38577,6 @@ var ts;
                 }
                 return bestMatchKind;
             }
-            // This means "compare in a case insensitive manner."
-            var baseSensitivity = { sensitivity: "base" };
             function compareNavigateToItems(i1, i2) {
                 // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
                 // Right now we just sort by kind first, and then by name of the item.
@@ -38296,8 +38739,8 @@ var ts;
             }
             function addTopLevelNodes(nodes, topLevelNodes) {
                 nodes = sortNodes(nodes);
-                for (var _i = 0; _i < nodes.length; _i++) {
-                    var node = nodes[_i];
+                for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
+                    var node = nodes_4[_i];
                     switch (node.kind) {
                         case 214 /* ClassDeclaration */:
                         case 217 /* EnumDeclaration */:
@@ -38340,8 +38783,8 @@ var ts;
             function getItemsWorker(nodes, createItem) {
                 var items = [];
                 var keyToItem = {};
-                for (var _i = 0; _i < nodes.length; _i++) {
-                    var child = nodes[_i];
+                for (var _i = 0, nodes_5 = nodes; _i < nodes_5.length; _i++) {
+                    var child = nodes_5[_i];
                     var item = createItem(child);
                     if (item !== undefined) {
                         if (item.text.length > 0) {
@@ -38389,7 +38832,7 @@ var ts;
                         if (ts.isBindingPattern(node.name)) {
                             break;
                         }
-                        if ((node.flags & 2035 /* Modifier */) === 0) {
+                        if ((node.flags & 1022 /* Modifier */) === 0) {
                             return undefined;
                         }
                         return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement);
@@ -38693,8 +39136,8 @@ var ts;
                     //    word part. That way we don't match something like 'Class' when the user types 'a'.
                     //    But we would match 'FooAttribute' (since 'Attribute' starts with 'a').
                     var wordSpans = getWordSpans(candidate);
-                    for (var _i = 0; _i < wordSpans.length; _i++) {
-                        var span = wordSpans[_i];
+                    for (var _i = 0, wordSpans_1 = wordSpans; _i < wordSpans_1.length; _i++) {
+                        var span = wordSpans_1[_i];
                         if (partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ true)) {
                             return createPatternMatch(PatternMatchKind.substring, punctuationStripped, 
                             /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ false));
@@ -38800,8 +39243,8 @@ var ts;
             // Only if all words have some sort of match is the pattern considered matched.
             var subWordTextChunks = segment.subWordTextChunks;
             var matches = undefined;
-            for (var _i = 0; _i < subWordTextChunks.length; _i++) {
-                var subWordTextChunk = subWordTextChunks[_i];
+            for (var _i = 0, subWordTextChunks_1 = subWordTextChunks; _i < subWordTextChunks_1.length; _i++) {
+                var subWordTextChunk = subWordTextChunks_1[_i];
                 // Try to match the candidate with this word
                 var result = matchTextChunk(candidate, subWordTextChunk, /*punctuationStripped:*/ true);
                 if (!result) {
@@ -39386,8 +39829,8 @@ var ts;
                     var nameToDeclarations = sourceFile_1.getNamedDeclarations();
                     var declarations = ts.getProperty(nameToDeclarations, name.text);
                     if (declarations) {
-                        for (var _b = 0; _b < declarations.length; _b++) {
-                            var declaration = declarations[_b];
+                        for (var _b = 0, declarations_7 = declarations; _b < declarations_7.length; _b++) {
+                            var declaration = declarations_7[_b];
                             var symbol = declaration.symbol;
                             if (symbol) {
                                 var type = typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
@@ -39503,8 +39946,8 @@ var ts;
                 // arg index.
                 var argumentIndex = 0;
                 var listChildren = argumentsList.getChildren();
-                for (var _i = 0; _i < listChildren.length; _i++) {
-                    var child = listChildren[_i];
+                for (var _i = 0, listChildren_1 = listChildren; _i < listChildren_1.length; _i++) {
+                    var child = listChildren_1[_i];
                     if (child === node) {
                         break;
                     }
@@ -40049,8 +40492,8 @@ var ts;
                 return n;
             }
             var children = n.getChildren();
-            for (var _i = 0; _i < children.length; _i++) {
-                var child = children[_i];
+            for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+                var child = children_1[_i];
                 var shouldDiveInChildNode = 
                 // previous token is enclosed somewhere in the child
                 (child.pos <= previousToken.pos && child.end > previousToken.end) ||
@@ -40212,17 +40655,17 @@ var ts;
     function getNodeModifiers(node) {
         var flags = ts.getCombinedNodeFlags(node);
         var result = [];
-        if (flags & 32 /* Private */)
+        if (flags & 16 /* Private */)
             result.push(ts.ScriptElementKindModifier.privateMemberModifier);
-        if (flags & 64 /* Protected */)
+        if (flags & 32 /* Protected */)
             result.push(ts.ScriptElementKindModifier.protectedMemberModifier);
-        if (flags & 16 /* Public */)
+        if (flags & 8 /* Public */)
             result.push(ts.ScriptElementKindModifier.publicMemberModifier);
-        if (flags & 128 /* Static */)
+        if (flags & 64 /* Static */)
             result.push(ts.ScriptElementKindModifier.staticModifier);
-        if (flags & 256 /* Abstract */)
+        if (flags & 128 /* Abstract */)
             result.push(ts.ScriptElementKindModifier.abstractModifier);
-        if (flags & 1 /* Export */)
+        if (flags & 2 /* Export */)
             result.push(ts.ScriptElementKindModifier.exportedModifier);
         if (ts.isInAmbientContext(node))
             result.push(ts.ScriptElementKindModifier.ambientModifier);
@@ -42366,8 +42809,8 @@ var ts;
                         }
                     }
                     var inheritedIndentation = -1 /* Unknown */;
-                    for (var _i = 0; _i < nodes.length; _i++) {
-                        var child = nodes[_i];
+                    for (var _i = 0, nodes_6 = nodes; _i < nodes_6.length; _i++) {
+                        var child = nodes_6[_i];
                         inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, /*isListElement*/ true);
                     }
                     if (listEndToken !== 0 /* Unknown */) {
@@ -42458,8 +42901,8 @@ var ts;
                 }
             }
             function processTrivia(trivia, parent, contextNode, dynamicIndentation) {
-                for (var _i = 0; _i < trivia.length; _i++) {
-                    var triviaItem = trivia[_i];
+                for (var _i = 0, trivia_1 = trivia; _i < trivia_1.length; _i++) {
+                    var triviaItem = trivia_1[_i];
                     if (ts.isComment(triviaItem.kind) && ts.rangeContainsRange(originalRange, triviaItem)) {
                         var triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos);
                         processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation);
@@ -43056,7 +43499,6 @@ var ts;
                                 return node;
                         }
                     }
-                    return node;
                 }
             }
             function deriveActualIndentationFromList(list, index, sourceFile, options) {
@@ -43307,17 +43749,17 @@ var ts;
             while (pos < end) {
                 var token = scanner.scan();
                 var textPos = scanner.getTextPos();
-                nodes.push(createNode(token, pos, textPos, 4096 /* Synthetic */, this));
+                nodes.push(createNode(token, pos, textPos, 2048 /* Synthetic */, this));
                 pos = textPos;
             }
             return pos;
         };
         NodeObject.prototype.createSyntaxList = function (nodes) {
-            var list = createNode(271 /* SyntaxList */, nodes.pos, nodes.end, 4096 /* Synthetic */, this);
+            var list = createNode(271 /* SyntaxList */, nodes.pos, nodes.end, 2048 /* Synthetic */, this);
             list._children = [];
             var pos = nodes.pos;
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_7 = nodes; _i < nodes_7.length; _i++) {
+                var node = nodes_7[_i];
                 if (pos < node.pos) {
                     pos = this.addSyntheticNodes(list._children, pos, node.pos);
                 }
@@ -43872,7 +44314,7 @@ var ts;
                         break;
                     case 138 /* Parameter */:
                         // Only consider properties defined as constructor parameters
-                        if (!(node.flags & 112 /* AccessibilityModifier */)) {
+                        if (!(node.flags & 56 /* AccessibilityModifier */)) {
                             break;
                         }
                     // fall through
@@ -44148,13 +44590,15 @@ var ts;
     var HostCache = (function () {
         function HostCache(host, getCanonicalFileName) {
             this.host = host;
+            this.getCanonicalFileName = getCanonicalFileName;
             // script id => script index
-            this.fileNameToEntry = ts.createFileMap(getCanonicalFileName);
+            this.currentDirectory = host.getCurrentDirectory();
+            this.fileNameToEntry = ts.createFileMap();
             // Initialize the list with the root file names
             var rootFileNames = host.getScriptFileNames();
-            for (var _i = 0; _i < rootFileNames.length; _i++) {
-                var fileName = rootFileNames[_i];
-                this.createEntry(fileName);
+            for (var _i = 0, rootFileNames_1 = rootFileNames; _i < rootFileNames_1.length; _i++) {
+                var fileName = rootFileNames_1[_i];
+                this.createEntry(fileName, ts.toPath(fileName, this.currentDirectory, getCanonicalFileName));
             }
             // store the compilation settings
             this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
@@ -44162,7 +44606,7 @@ var ts;
         HostCache.prototype.compilationSettings = function () {
             return this._compilationSettings;
         };
-        HostCache.prototype.createEntry = function (fileName) {
+        HostCache.prototype.createEntry = function (fileName, path) {
             var entry;
             var scriptSnapshot = this.host.getScriptSnapshot(fileName);
             if (scriptSnapshot) {
@@ -44172,36 +44616,37 @@ var ts;
                     scriptSnapshot: scriptSnapshot
                 };
             }
-            this.fileNameToEntry.set(fileName, entry);
+            this.fileNameToEntry.set(path, entry);
             return entry;
         };
-        HostCache.prototype.getEntry = function (fileName) {
-            return this.fileNameToEntry.get(fileName);
+        HostCache.prototype.getEntry = function (path) {
+            return this.fileNameToEntry.get(path);
         };
-        HostCache.prototype.contains = function (fileName) {
-            return this.fileNameToEntry.contains(fileName);
+        HostCache.prototype.contains = function (path) {
+            return this.fileNameToEntry.contains(path);
         };
         HostCache.prototype.getOrCreateEntry = function (fileName) {
-            if (this.contains(fileName)) {
-                return this.getEntry(fileName);
+            var path = ts.toPath(fileName, this.currentDirectory, this.getCanonicalFileName);
+            if (this.contains(path)) {
+                return this.getEntry(path);
             }
-            return this.createEntry(fileName);
+            return this.createEntry(fileName, path);
         };
         HostCache.prototype.getRootFileNames = function () {
             var fileNames = [];
-            this.fileNameToEntry.forEachValue(function (value) {
+            this.fileNameToEntry.forEachValue(function (path, value) {
                 if (value) {
                     fileNames.push(value.hostFileName);
                 }
             });
             return fileNames;
         };
-        HostCache.prototype.getVersion = function (fileName) {
-            var file = this.getEntry(fileName);
+        HostCache.prototype.getVersion = function (path) {
+            var file = this.getEntry(path);
             return file && file.version;
         };
-        HostCache.prototype.getScriptSnapshot = function (fileName) {
-            var file = this.getEntry(fileName);
+        HostCache.prototype.getScriptSnapshot = function (path) {
+            var file = this.getEntry(path);
             return file && file.scriptSnapshot;
         };
         return HostCache;
@@ -44383,7 +44828,8 @@ var ts;
             : (function (fileName) { return fileName.toLowerCase(); });
     }
     ts.createGetCanonicalFileName = createGetCanonicalFileName;
-    function createDocumentRegistry(useCaseSensitiveFileNames) {
+    function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) {
+        if (currentDirectory === void 0) { currentDirectory = ""; }
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.
         var buckets = {};
@@ -44395,7 +44841,7 @@ var ts;
             var key = getKeyFromCompilationSettings(settings);
             var bucket = ts.lookUp(buckets, key);
             if (!bucket && createIfMissing) {
-                buckets[key] = bucket = ts.createFileMap(getCanonicalFileName);
+                buckets[key] = bucket = ts.createFileMap();
             }
             return bucket;
         }
@@ -44403,14 +44849,13 @@ var ts;
             var bucketInfoArray = Object.keys(buckets).filter(function (name) { return name && name.charAt(0) === '_'; }).map(function (name) {
                 var entries = ts.lookUp(buckets, name);
                 var sourceFiles = [];
-                for (var i in entries) {
-                    var entry = entries.get(i);
+                entries.forEachValue(function (key, entry) {
                     sourceFiles.push({
-                        name: i,
+                        name: key,
                         refCount: entry.languageServiceRefCount,
                         references: entry.owners.slice(0)
                     });
-                }
+                });
                 sourceFiles.sort(function (x, y) { return y.refCount - x.refCount; });
                 return {
                     bucket: name,
@@ -44427,7 +44872,8 @@ var ts;
         }
         function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) {
             var bucket = getBucketForCompilationSettings(compilationSettings, /*createIfMissing*/ true);
-            var entry = bucket.get(fileName);
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var entry = bucket.get(path);
             if (!entry) {
                 ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?");
                 // Have never seen this file with these settings.  Create a new source file for it.
@@ -44437,7 +44883,7 @@ var ts;
                     languageServiceRefCount: 0,
                     owners: []
                 };
-                bucket.set(fileName, entry);
+                bucket.set(path, entry);
             }
             else {
                 // We have an entry for this file.  However, it may be for a different version of
@@ -44460,11 +44906,12 @@ var ts;
         function releaseDocument(fileName, compilationSettings) {
             var bucket = getBucketForCompilationSettings(compilationSettings, false);
             ts.Debug.assert(bucket !== undefined);
-            var entry = bucket.get(fileName);
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var entry = bucket.get(path);
             entry.languageServiceRefCount--;
             ts.Debug.assert(entry.languageServiceRefCount >= 0);
             if (entry.languageServiceRefCount === 0) {
-                bucket.remove(fileName);
+                bucket.remove(path);
             }
         }
         return {
@@ -44871,7 +45318,7 @@ var ts;
             case 144 /* Constructor */: return ScriptElementKind.constructorImplementationElement;
             case 137 /* TypeParameter */: return ScriptElementKind.typeParameterElement;
             case 247 /* EnumMember */: return ScriptElementKind.variableElement;
-            case 138 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
+            case 138 /* Parameter */: return (node.flags & 56 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
             case 221 /* ImportEqualsDeclaration */:
             case 226 /* ImportSpecifier */:
             case 223 /* ImportClause */:
@@ -44897,13 +45344,14 @@ var ts;
         return CancellationTokenObject;
     })();
     function createLanguageService(host, documentRegistry) {
-        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(); }
+        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()); }
         var syntaxTreeCache = new SyntaxTreeCache(host);
         var ruleProvider;
         var program;
         var lastProjectVersion;
         var useCaseSensitivefileNames = false;
         var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
+        var currentDirectory = host.getCurrentDirectory();
         // Check if the localized messages json is set, otherwise query the host for it
         if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) {
             ts.localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages();
@@ -44915,8 +45363,7 @@ var ts;
         }
         var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames);
         function getValidSourceFile(fileName) {
-            fileName = ts.normalizeSlashes(fileName);
-            var sourceFile = program.getSourceFile(getCanonicalFileName(fileName));
+            var sourceFile = program.getSourceFile(fileName);
             if (!sourceFile) {
                 throw new Error("Could not find file: '" + fileName + "'.");
             }
@@ -44968,7 +45415,7 @@ var ts;
                 getNewLine: function () { return ts.getNewLineOrDefaultFromHost(host); },
                 getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); },
                 writeFile: function (fileName, data, writeByteOrderMark) { },
-                getCurrentDirectory: function () { return host.getCurrentDirectory(); },
+                getCurrentDirectory: function () { return currentDirectory; },
                 fileExists: function (fileName) {
                     // stub missing host functionality
                     ts.Debug.assert(!host.resolveModuleNames);
@@ -44988,11 +45435,10 @@ var ts;
             // not part of the new program.
             if (program) {
                 var oldSourceFiles = program.getSourceFiles();
-                for (var _i = 0; _i < oldSourceFiles.length; _i++) {
-                    var oldSourceFile = oldSourceFiles[_i];
-                    var fileName = oldSourceFile.fileName;
-                    if (!newProgram.getSourceFile(fileName) || changesInCompilationSettingsAffectSyntax) {
-                        documentRegistry.releaseDocument(fileName, oldSettings);
+                for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) {
+                    var oldSourceFile = oldSourceFiles_1[_i];
+                    if (!newProgram.getSourceFile(oldSourceFile.fileName) || changesInCompilationSettingsAffectSyntax) {
+                        documentRegistry.releaseDocument(oldSourceFile.fileName, oldSettings);
                     }
                 }
             }
@@ -45048,7 +45494,8 @@ var ts;
                 return documentRegistry.acquireDocument(fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version);
             }
             function sourceFileUpToDate(sourceFile) {
-                return sourceFile && sourceFile.version === hostCache.getVersion(sourceFile.fileName);
+                var path = sourceFile.path || ts.toPath(sourceFile.fileName, currentDirectory, getCanonicalFileName);
+                return sourceFile && sourceFile.version === hostCache.getVersion(path);
             }
             function programUpToDate() {
                 // If we haven't create a program yet, then it is not up-to-date
@@ -45061,8 +45508,8 @@ var ts;
                     return false;
                 }
                 // If any file is not up-to-date, then the whole program is not up-to-date
-                for (var _i = 0; _i < rootFileNames.length; _i++) {
-                    var fileName = rootFileNames[_i];
+                for (var _i = 0, rootFileNames_2 = rootFileNames; _i < rootFileNames_2.length; _i++) {
+                    var fileName = rootFileNames_2[_i];
                     if (!sourceFileUpToDate(program.getSourceFile(fileName))) {
                         return false;
                     }
@@ -45237,8 +45684,8 @@ var ts;
             }
             function checkModifiers(modifiers) {
                 if (modifiers) {
-                    for (var _i = 0; _i < modifiers.length; _i++) {
-                        var modifier = modifiers[_i];
+                    for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
+                        var modifier = modifiers_1[_i];
                         switch (modifier.kind) {
                             case 112 /* PublicKeyword */:
                             case 110 /* PrivateKeyword */:
@@ -45940,8 +46387,8 @@ var ts;
              */
             function filterNamedImportOrExportCompletionItems(exportsOfModule, namedImportsOrExports) {
                 var exisingImportsOrExports = {};
-                for (var _i = 0; _i < namedImportsOrExports.length; _i++) {
-                    var element = namedImportsOrExports[_i];
+                for (var _i = 0, namedImportsOrExports_1 = namedImportsOrExports; _i < namedImportsOrExports_1.length; _i++) {
+                    var element = namedImportsOrExports_1[_i];
                     // If this is the current item we are editing right now, do not filter it out
                     if (element.getStart() <= position && position <= element.getEnd()) {
                         continue;
@@ -45965,8 +46412,8 @@ var ts;
                     return contextualMemberSymbols;
                 }
                 var existingMemberNames = {};
-                for (var _i = 0; _i < existingMembers.length; _i++) {
-                    var m = existingMembers[_i];
+                for (var _i = 0, existingMembers_1 = existingMembers; _i < existingMembers_1.length; _i++) {
+                    var m = existingMembers_1[_i];
                     // Ignore omitted expressions for missing members
                     if (m.kind !== 245 /* PropertyAssignment */ &&
                         m.kind !== 246 /* ShorthandPropertyAssignment */ &&
@@ -45999,8 +46446,8 @@ var ts;
              */
             function filterJsxAttributes(symbols, attributes) {
                 var seenNames = {};
-                for (var _i = 0; _i < attributes.length; _i++) {
-                    var attr = attributes[_i];
+                for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
+                    var attr = attributes_1[_i];
                     // If this is the current item we are editing right now, do not filter it out
                     if (attr.getStart() <= position && position <= attr.getEnd()) {
                         continue;
@@ -46101,8 +46548,8 @@ var ts;
                 var entries = [];
                 if (symbols) {
                     var nameToSymbol = {};
-                    for (var _i = 0; _i < symbols.length; _i++) {
-                        var symbol = symbols[_i];
+                    for (var _i = 0, symbols_3 = symbols; _i < symbols_3.length; _i++) {
+                        var symbol = symbols_3[_i];
                         var entry = createCompletionEntry(symbol, location);
                         if (entry) {
                             var id = ts.escapeIdentifier(entry.name);
@@ -46844,8 +47291,8 @@ var ts;
                     }
                     var fileNameToDocumentHighlights = {};
                     var result = [];
-                    for (var _i = 0; _i < referencedSymbols.length; _i++) {
-                        var referencedSymbol = referencedSymbols[_i];
+                    for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) {
+                        var referencedSymbol = referencedSymbols_1[_i];
                         for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
                             var referenceEntry = _b[_a];
                             var fileName_1 = referenceEntry.fileName;
@@ -46989,7 +47436,6 @@ var ts;
                             ts.forEachChild(node, aggregate);
                         }
                     }
-                    ;
                 }
                 /**
                  * For lack of a better name, this function takes a throw statement and returns the
@@ -47027,7 +47473,6 @@ var ts;
                             ts.forEachChild(node, aggregate);
                         }
                     }
-                    ;
                 }
                 function ownsBreakOrContinueStatement(owner, statement) {
                     var actualOwner = getBreakOrContinueOwner(statement);
@@ -47096,7 +47541,7 @@ var ts;
                         case 219 /* ModuleBlock */:
                         case 248 /* SourceFile */:
                             // Container is either a class declaration or the declaration is a classDeclaration
-                            if (modifierFlag & 256 /* Abstract */) {
+                            if (modifierFlag & 128 /* Abstract */) {
                                 nodes = declaration.members.concat(declaration);
                             }
                             else {
@@ -47111,7 +47556,7 @@ var ts;
                             nodes = container.members;
                             // If we're an accessibility modifier, we're in an instance member and should search
                             // the constructor's parameter list for instance members as well.
-                            if (modifierFlag & 112 /* AccessibilityModifier */) {
+                            if (modifierFlag & 56 /* AccessibilityModifier */) {
                                 var constructor = ts.forEach(container.members, function (member) {
                                     return member.kind === 144 /* Constructor */ && member;
                                 });
@@ -47119,7 +47564,7 @@ var ts;
                                     nodes = nodes.concat(constructor.parameters);
                                 }
                             }
-                            else if (modifierFlag & 256 /* Abstract */) {
+                            else if (modifierFlag & 128 /* Abstract */) {
                                 nodes = nodes.concat(container);
                             }
                             break;
@@ -47135,19 +47580,19 @@ var ts;
                     function getFlagFromModifier(modifier) {
                         switch (modifier) {
                             case 112 /* PublicKeyword */:
-                                return 16 /* Public */;
+                                return 8 /* Public */;
                             case 110 /* PrivateKeyword */:
-                                return 32 /* Private */;
+                                return 16 /* Private */;
                             case 111 /* ProtectedKeyword */:
-                                return 64 /* Protected */;
+                                return 32 /* Protected */;
                             case 113 /* StaticKeyword */:
-                                return 128 /* Static */;
+                                return 64 /* Static */;
                             case 82 /* ExportKeyword */:
-                                return 1 /* Export */;
+                                return 2 /* Export */;
                             case 122 /* DeclareKeyword */:
-                                return 2 /* Ambient */;
+                                return 4 /* Ambient */;
                             case 115 /* AbstractKeyword */:
-                                return 256 /* Abstract */;
+                                return 128 /* Abstract */;
                             default:
                                 ts.Debug.fail();
                         }
@@ -47346,8 +47791,8 @@ var ts;
                     return undefined;
                 }
                 var result = [];
-                for (var _i = 0; _i < documentHighlights.length; _i++) {
-                    var entry = documentHighlights[_i];
+                for (var _i = 0, documentHighlights_1 = documentHighlights; _i < documentHighlights_1.length; _i++) {
+                    var entry = documentHighlights_1[_i];
                     for (var _a = 0, _b = entry.highlightSpans; _a < _b.length; _a++) {
                         var highlightSpan = _b[_a];
                         result.push({
@@ -47365,8 +47810,8 @@ var ts;
                 return undefined;
             }
             var referenceEntries = [];
-            for (var _i = 0; _i < referenceSymbols.length; _i++) {
-                var referenceSymbol = referenceSymbols[_i];
+            for (var _i = 0, referenceSymbols_1 = referenceSymbols; _i < referenceSymbols_1.length; _i++) {
+                var referenceSymbol = referenceSymbols_1[_i];
                 ts.addRange(referenceEntries, referenceSymbol.references);
             }
             return referenceEntries;
@@ -47451,8 +47896,8 @@ var ts;
             }
             else {
                 var internedName = getInternedName(symbol, node, declarations);
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) {
+                    var sourceFile = sourceFiles_2[_i];
                     cancellationToken.throwIfCancellationRequested();
                     var nameTable = getNameTable(sourceFile);
                     if (ts.lookUp(nameTable, internedName)) {
@@ -47512,7 +47957,7 @@ var ts;
                 }
                 // If this is private property or method, the scope is the containing class
                 if (symbol.flags & (4 /* Property */ | 8192 /* Method */)) {
-                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32 /* Private */) ? d : undefined; });
+                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 16 /* Private */) ? d : undefined; });
                     if (privateDeclaration) {
                         return ts.getAncestor(privateDeclaration, 214 /* ClassDeclaration */);
                     }
@@ -47530,8 +47975,8 @@ var ts;
                 var scope = undefined;
                 var declarations = symbol.getDeclarations();
                 if (declarations) {
-                    for (var _i = 0; _i < declarations.length; _i++) {
-                        var declaration = declarations[_i];
+                    for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
+                        var declaration = declarations_8[_i];
                         var container = getContainerNode(declaration);
                         if (!container) {
                             return undefined;
@@ -47711,7 +48156,7 @@ var ts;
                     return undefined;
                 }
                 // Whether 'super' occurs in a static context within a class.
-                var staticFlag = 128 /* Static */;
+                var staticFlag = 64 /* Static */;
                 switch (searchSpaceNode.kind) {
                     case 141 /* PropertyDeclaration */:
                     case 140 /* PropertySignature */:
@@ -47739,7 +48184,7 @@ var ts;
                     // If we have a 'super' container, we must have an enclosing class.
                     // Now make sure the owning class is the same as the search-space
                     // and has the same static qualifier as the original 'super's owner.
-                    if (container && (128 /* Static */ & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
+                    if (container && (64 /* Static */ & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
                         references.push(getReferenceEntryFromNode(node));
                     }
                 });
@@ -47749,7 +48194,7 @@ var ts;
             function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles) {
                 var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false);
                 // Whether 'this' occurs in a static context within a class.
-                var staticFlag = 128 /* Static */;
+                var staticFlag = 64 /* Static */;
                 switch (searchSpaceNode.kind) {
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
@@ -47827,7 +48272,7 @@ var ts;
                             case 214 /* ClassDeclaration */:
                                 // Make sure the container belongs to the same class
                                 // and has the appropriate static modifier from the original container.
-                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128 /* Static */) === staticFlag) {
+                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 64 /* Static */) === staticFlag) {
                                     result.push(getReferenceEntryFromNode(node));
                                 }
                                 break;
@@ -47998,8 +48443,8 @@ var ts;
                         // To achieve that we will keep iterating until the result stabilizes.
                         // Remember the last meaning
                         lastIterationMeaning = meaning;
-                        for (var _i = 0; _i < declarations.length; _i++) {
-                            var declaration = declarations[_i];
+                        for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
+                            var declaration = declarations_9[_i];
                             var declarationMeaning = getMeaningFromDeclaration(declaration);
                             if (declarationMeaning & meaning) {
                                 meaning |= declarationMeaning;
@@ -48115,7 +48560,6 @@ var ts;
                     return 4 /* Namespace */ | 1 /* Value */;
             }
             return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */;
-            ts.Debug.fail("Unknown declaration type");
         }
         function isTypeReference(node) {
             if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) {
@@ -48694,8 +49138,8 @@ var ts;
                 if (matchKind) {
                     var parentElement = token.parent;
                     var childNodes = parentElement.getChildren(sourceFile);
-                    for (var _i = 0; _i < childNodes.length; _i++) {
-                        var current = childNodes[_i];
+                    for (var _i = 0, childNodes_1 = childNodes; _i < childNodes_1.length; _i++) {
+                        var current = childNodes_1[_i];
                         if (current.kind === matchKind) {
                             var range1 = ts.createTextSpan(token.getStart(sourceFile), token.getWidth(sourceFile));
                             var range2 = ts.createTextSpan(current.getStart(sourceFile), current.getWidth(sourceFile));
@@ -49025,8 +49469,8 @@ var ts;
                         // Disallow rename for elements that are defined in the standard TypeScript library.
                         var defaultLibFileName = host.getDefaultLibFileName(host.getCompilationSettings());
                         if (defaultLibFileName) {
-                            for (var _i = 0; _i < declarations.length; _i++) {
-                                var current = declarations[_i];
+                            for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) {
+                                var current = declarations_10[_i];
                                 var sourceFile_2 = current.getSourceFile();
                                 var canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName));
                                 if (sourceFile_2 && getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName)) === getCanonicalFileName(ts.normalizePath(defaultLibFileName))) {
@@ -49609,7 +50053,7 @@ var ts;
          */
         function spanInSourceFileAtLocation(sourceFile, position) {
             // Cannot set breakpoint in dts file
-            if (sourceFile.flags & 8192 /* DeclarationFile */) {
+            if (sourceFile.flags & 4096 /* DeclarationFile */) {
                 return undefined;
             }
             var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position);
@@ -49827,7 +50271,7 @@ var ts;
                             ? variableDeclaration.parent.parent.initializer.declarations
                             : undefined;
                     // Breakpoint is possible in variableDeclaration only if there is initialization
-                    if (variableDeclaration.initializer || (variableDeclaration.flags & 1 /* Export */)) {
+                    if (variableDeclaration.initializer || (variableDeclaration.flags & 2 /* Export */)) {
                         if (declarations && declarations[0] === variableDeclaration) {
                             if (isParentVariableStatement) {
                                 // First declaration - include let keyword
@@ -49853,7 +50297,7 @@ var ts;
                 function canHaveSpanInParameterDeclaration(parameter) {
                     // Breakpoint is possible on parameter only if it has initializer, is a rest parameter, or has public or private modifier
                     return !!parameter.initializer || parameter.dotDotDotToken !== undefined ||
-                        !!(parameter.flags & 16 /* Public */) || !!(parameter.flags & 32 /* Private */);
+                        !!(parameter.flags & 8 /* Public */) || !!(parameter.flags & 16 /* Private */);
                 }
                 function spanInParameterDeclaration(parameter) {
                     if (canHaveSpanInParameterDeclaration(parameter)) {
@@ -49873,7 +50317,7 @@ var ts;
                     }
                 }
                 function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) {
-                    return !!(functionDeclaration.flags & 1 /* Export */) ||
+                    return !!(functionDeclaration.flags & 2 /* Export */) ||
                         (functionDeclaration.parent.kind === 214 /* ClassDeclaration */ && functionDeclaration.kind !== 144 /* Constructor */);
                 }
                 function spanInFunctionDeclaration(functionDeclaration) {
@@ -49967,7 +50411,6 @@ var ts;
                         // fall through.
                         case 244 /* CatchClause */:
                             return spanInNode(ts.lastOrUndefined(node.parent.statements));
-                            ;
                         case 220 /* CaseBlock */:
                             // breakpoint in last statement of the last clause
                             var caseBlock = node.parent;
@@ -50008,8 +50451,6 @@ var ts;
                         default:
                             return spanInNode(node.parent);
                     }
-                    // Default to parent node
-                    return spanInNode(node.parent);
                 }
                 function spanInColonToken(node) {
                     // Is this : specifying return annotation of the function declaration
@@ -50138,7 +50579,6 @@ var ts;
             // TODO: should this be '==='?
             if (settingsJson == null || settingsJson == "") {
                 throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
-                return null;
             }
             return JSON.parse(settingsJson);
         };
diff --git a/lib/typescriptServices.d.ts b/lib/typescriptServices.d.ts
index badaff1c3e2..d2758e6d5e9 100644
--- a/lib/typescriptServices.d.ts
+++ b/lib/typescriptServices.d.ts
@@ -17,19 +17,22 @@ declare namespace ts {
     interface Map<T> {
         [index: string]: T;
     }
+    type Path = string & {
+        __pathBrand: any;
+    };
     interface FileMap<T> {
-        get(fileName: string): T;
-        set(fileName: string, value: T): void;
-        contains(fileName: string): boolean;
-        remove(fileName: string): void;
-        forEachValue(f: (v: T) => void): void;
+        get(fileName: Path): T;
+        set(fileName: Path, value: T): void;
+        contains(fileName: Path): boolean;
+        remove(fileName: Path): void;
+        forEachValue(f: (key: Path, v: T) => void): void;
         clear(): void;
     }
     interface TextRange {
         pos: number;
         end: number;
     }
-    const enum SyntaxKind {
+    enum SyntaxKind {
         Unknown = 0,
         EndOfFileToken = 1,
         SingleLineCommentTrivia = 2,
@@ -327,31 +330,34 @@ declare namespace ts {
         LastBinaryOperator = 68,
         FirstNode = 135,
     }
-    const enum NodeFlags {
+    enum NodeFlags {
         None = 0,
-        Export = 1,
-        Ambient = 2,
-        Public = 16,
-        Private = 32,
-        Protected = 64,
-        Static = 128,
-        Abstract = 256,
-        Async = 512,
-        Default = 1024,
-        MultiLine = 2048,
-        Synthetic = 4096,
-        DeclarationFile = 8192,
-        Let = 16384,
-        Const = 32768,
-        OctalLiteral = 65536,
-        Namespace = 131072,
-        ExportContext = 262144,
-        ContainsThis = 524288,
-        Modifier = 2035,
-        AccessibilityModifier = 112,
-        BlockScoped = 49152,
+        Export = 2,
+        Ambient = 4,
+        Public = 8,
+        Private = 16,
+        Protected = 32,
+        Static = 64,
+        Abstract = 128,
+        Async = 256,
+        Default = 512,
+        MultiLine = 1024,
+        Synthetic = 2048,
+        DeclarationFile = 4096,
+        Let = 8192,
+        Const = 16384,
+        OctalLiteral = 32768,
+        Namespace = 65536,
+        ExportContext = 131072,
+        ContainsThis = 262144,
+        HasImplicitReturn = 524288,
+        HasExplicitReturn = 1048576,
+        Modifier = 1022,
+        AccessibilityModifier = 56,
+        BlockScoped = 24576,
+        ReachabilityCheckFlags = 1572864,
     }
-    const enum JsxFlags {
+    enum JsxFlags {
         None = 0,
         IntrinsicNamedElement = 1,
         IntrinsicIndexedElement = 2,
@@ -931,6 +937,7 @@ declare namespace ts {
         statements: NodeArray<Statement>;
         endOfFileToken: Node;
         fileName: string;
+        path: Path;
         text: string;
         amdDependencies: {
             path: string;
@@ -1093,7 +1100,7 @@ declare namespace ts {
         trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
         reportInaccessibleThisError(): void;
     }
-    const enum TypeFormatFlags {
+    enum TypeFormatFlags {
         None = 0,
         WriteArrayAsGenericType = 1,
         UseTypeOfFunction = 2,
@@ -1104,7 +1111,7 @@ declare namespace ts {
         InElementType = 64,
         UseFullyQualifiedType = 128,
     }
-    const enum SymbolFormatFlags {
+    enum SymbolFormatFlags {
         None = 0,
         WriteTypeParametersOrArguments = 1,
         UseOnlyExternalAliasing = 2,
@@ -1114,7 +1121,7 @@ declare namespace ts {
         parameterIndex: number;
         type: Type;
     }
-    const enum SymbolFlags {
+    enum SymbolFlags {
         None = 0,
         FunctionScopedVariable = 1,
         BlockScopedVariable = 2,
@@ -1191,7 +1198,7 @@ declare namespace ts {
     interface SymbolTable {
         [index: string]: Symbol;
     }
-    const enum TypeFlags {
+    enum TypeFlags {
         Any = 1,
         String = 2,
         Number = 4,
@@ -1262,7 +1269,7 @@ declare namespace ts {
     interface TypeParameter extends Type {
         constraint: Type;
     }
-    const enum SignatureKind {
+    enum SignatureKind {
         Call = 0,
         Construct = 1,
     }
@@ -1272,7 +1279,7 @@ declare namespace ts {
         parameters: Symbol[];
         typePredicate?: TypePredicate;
     }
-    const enum IndexKind {
+    enum IndexKind {
         String = 0,
         Number = 1,
     }
@@ -1307,7 +1314,7 @@ declare namespace ts {
         Error = 1,
         Message = 2,
     }
-    const enum ModuleResolutionKind {
+    enum ModuleResolutionKind {
         Classic = 1,
         NodeJs = 2,
     }
@@ -1352,10 +1359,14 @@ declare namespace ts {
         experimentalDecorators?: boolean;
         emitDecoratorMetadata?: boolean;
         moduleResolution?: ModuleResolutionKind;
+        allowUnusedLabels?: boolean;
+        allowUnreachableCode?: boolean;
+        noImplicitReturns?: boolean;
+        noFallthroughCasesInSwitch?: boolean;
         forceConsistentCasingInFileNames?: boolean;
         [option: string]: string | number | boolean;
     }
-    const enum ModuleKind {
+    enum ModuleKind {
         None = 0,
         CommonJS = 1,
         AMD = 2,
@@ -1364,12 +1375,12 @@ declare namespace ts {
         ES6 = 5,
         ES2015 = 5,
     }
-    const enum JsxEmit {
+    enum JsxEmit {
         None = 0,
         Preserve = 1,
         React = 2,
     }
-    const enum NewLineKind {
+    enum NewLineKind {
         CarriageReturnLineFeed = 0,
         LineFeed = 1,
     }
@@ -1377,14 +1388,14 @@ declare namespace ts {
         line: number;
         character: number;
     }
-    const enum ScriptTarget {
+    enum ScriptTarget {
         ES3 = 0,
         ES5 = 1,
         ES6 = 2,
         ES2015 = 2,
         Latest = 2,
     }
-    const enum LanguageVariant {
+    enum LanguageVariant {
         Standard = 0,
         JSX = 1,
     }
@@ -1938,7 +1949,7 @@ declare namespace ts {
         outputFiles: OutputFile[];
         emitSkipped: boolean;
     }
-    const enum OutputFileType {
+    enum OutputFileType {
         JavaScript = 0,
         SourceMap = 1,
         Declaration = 2,
@@ -1948,7 +1959,7 @@ declare namespace ts {
         writeByteOrderMark: boolean;
         text: string;
     }
-    const enum EndOfLineState {
+    enum EndOfLineState {
         None = 0,
         InMultiLineCommentTrivia = 1,
         InSingleQuoteStringLiteral = 2,
@@ -2116,7 +2127,7 @@ declare namespace ts {
         static parameterName: string;
         static docCommentTagName: string;
     }
-    const enum ClassificationType {
+    enum ClassificationType {
         comment = 1,
         identifier = 2,
         keyword = 3,
@@ -2159,7 +2170,7 @@ declare namespace ts {
     let disableIncrementalParsing: boolean;
     function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
     function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string;
-    function createDocumentRegistry(useCaseSensitiveFileNames?: boolean): DocumentRegistry;
+    function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;
     function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo;
     function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService;
     function createClassifier(): Classifier;
diff --git a/lib/typescriptServices.js b/lib/typescriptServices.js
index 1e0c0edad05..8b0ef04f96e 100644
--- a/lib/typescriptServices.js
+++ b/lib/typescriptServices.js
@@ -350,27 +350,30 @@ var ts;
     var SyntaxKind = ts.SyntaxKind;
     (function (NodeFlags) {
         NodeFlags[NodeFlags["None"] = 0] = "None";
-        NodeFlags[NodeFlags["Export"] = 1] = "Export";
-        NodeFlags[NodeFlags["Ambient"] = 2] = "Ambient";
-        NodeFlags[NodeFlags["Public"] = 16] = "Public";
-        NodeFlags[NodeFlags["Private"] = 32] = "Private";
-        NodeFlags[NodeFlags["Protected"] = 64] = "Protected";
-        NodeFlags[NodeFlags["Static"] = 128] = "Static";
-        NodeFlags[NodeFlags["Abstract"] = 256] = "Abstract";
-        NodeFlags[NodeFlags["Async"] = 512] = "Async";
-        NodeFlags[NodeFlags["Default"] = 1024] = "Default";
-        NodeFlags[NodeFlags["MultiLine"] = 2048] = "MultiLine";
-        NodeFlags[NodeFlags["Synthetic"] = 4096] = "Synthetic";
-        NodeFlags[NodeFlags["DeclarationFile"] = 8192] = "DeclarationFile";
-        NodeFlags[NodeFlags["Let"] = 16384] = "Let";
-        NodeFlags[NodeFlags["Const"] = 32768] = "Const";
-        NodeFlags[NodeFlags["OctalLiteral"] = 65536] = "OctalLiteral";
-        NodeFlags[NodeFlags["Namespace"] = 131072] = "Namespace";
-        NodeFlags[NodeFlags["ExportContext"] = 262144] = "ExportContext";
-        NodeFlags[NodeFlags["ContainsThis"] = 524288] = "ContainsThis";
-        NodeFlags[NodeFlags["Modifier"] = 2035] = "Modifier";
-        NodeFlags[NodeFlags["AccessibilityModifier"] = 112] = "AccessibilityModifier";
-        NodeFlags[NodeFlags["BlockScoped"] = 49152] = "BlockScoped";
+        NodeFlags[NodeFlags["Export"] = 2] = "Export";
+        NodeFlags[NodeFlags["Ambient"] = 4] = "Ambient";
+        NodeFlags[NodeFlags["Public"] = 8] = "Public";
+        NodeFlags[NodeFlags["Private"] = 16] = "Private";
+        NodeFlags[NodeFlags["Protected"] = 32] = "Protected";
+        NodeFlags[NodeFlags["Static"] = 64] = "Static";
+        NodeFlags[NodeFlags["Abstract"] = 128] = "Abstract";
+        NodeFlags[NodeFlags["Async"] = 256] = "Async";
+        NodeFlags[NodeFlags["Default"] = 512] = "Default";
+        NodeFlags[NodeFlags["MultiLine"] = 1024] = "MultiLine";
+        NodeFlags[NodeFlags["Synthetic"] = 2048] = "Synthetic";
+        NodeFlags[NodeFlags["DeclarationFile"] = 4096] = "DeclarationFile";
+        NodeFlags[NodeFlags["Let"] = 8192] = "Let";
+        NodeFlags[NodeFlags["Const"] = 16384] = "Const";
+        NodeFlags[NodeFlags["OctalLiteral"] = 32768] = "OctalLiteral";
+        NodeFlags[NodeFlags["Namespace"] = 65536] = "Namespace";
+        NodeFlags[NodeFlags["ExportContext"] = 131072] = "ExportContext";
+        NodeFlags[NodeFlags["ContainsThis"] = 262144] = "ContainsThis";
+        NodeFlags[NodeFlags["HasImplicitReturn"] = 524288] = "HasImplicitReturn";
+        NodeFlags[NodeFlags["HasExplicitReturn"] = 1048576] = "HasExplicitReturn";
+        NodeFlags[NodeFlags["Modifier"] = 1022] = "Modifier";
+        NodeFlags[NodeFlags["AccessibilityModifier"] = 56] = "AccessibilityModifier";
+        NodeFlags[NodeFlags["BlockScoped"] = 24576] = "BlockScoped";
+        NodeFlags[NodeFlags["ReachabilityCheckFlags"] = 1572864] = "ReachabilityCheckFlags";
     })(ts.NodeFlags || (ts.NodeFlags = {}));
     var NodeFlags = ts.NodeFlags;
     /* @internal */
@@ -690,6 +693,12 @@ var ts;
     })(ts.LanguageVariant || (ts.LanguageVariant = {}));
     var LanguageVariant = ts.LanguageVariant;
     /* @internal */
+    (function (DiagnosticStyle) {
+        DiagnosticStyle[DiagnosticStyle["Simple"] = 0] = "Simple";
+        DiagnosticStyle[DiagnosticStyle["Pretty"] = 1] = "Pretty";
+    })(ts.DiagnosticStyle || (ts.DiagnosticStyle = {}));
+    var DiagnosticStyle = ts.DiagnosticStyle;
+    /* @internal */
     (function (CharacterCodes) {
         CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
         CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
@@ -838,40 +847,50 @@ var ts;
         Ternary[Ternary["True"] = -1] = "True";
     })(ts.Ternary || (ts.Ternary = {}));
     var Ternary = ts.Ternary;
-    function createFileMap(getCanonicalFileName) {
+    function createFileMap(keyMapper) {
         var files = {};
         return {
             get: get,
             set: set,
             contains: contains,
             remove: remove,
-            clear: clear,
-            forEachValue: forEachValueInMap
+            forEachValue: forEachValueInMap,
+            clear: clear
         };
-        function set(fileName, value) {
-            files[normalizeKey(fileName)] = value;
-        }
-        function get(fileName) {
-            return files[normalizeKey(fileName)];
-        }
-        function contains(fileName) {
-            return hasProperty(files, normalizeKey(fileName));
-        }
-        function remove(fileName) {
-            var key = normalizeKey(fileName);
-            delete files[key];
-        }
         function forEachValueInMap(f) {
-            forEachValue(files, f);
+            for (var key in files) {
+                f(key, files[key]);
+            }
         }
-        function normalizeKey(key) {
-            return getCanonicalFileName(normalizeSlashes(key));
+        // path should already be well-formed so it does not need to be normalized
+        function get(path) {
+            return files[toKey(path)];
+        }
+        function set(path, value) {
+            files[toKey(path)] = value;
+        }
+        function contains(path) {
+            return hasProperty(files, toKey(path));
+        }
+        function remove(path) {
+            var key = toKey(path);
+            delete files[key];
         }
         function clear() {
             files = {};
         }
+        function toKey(path) {
+            return keyMapper ? keyMapper(path) : path;
+        }
     }
     ts.createFileMap = createFileMap;
+    function toPath(fileName, basePath, getCanonicalFileName) {
+        var nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return getCanonicalFileName(nonCanonicalizedPath);
+    }
+    ts.toPath = toPath;
     (function (Comparison) {
         Comparison[Comparison["LessThan"] = -1] = "LessThan";
         Comparison[Comparison["EqualTo"] = 0] = "EqualTo";
@@ -897,8 +916,8 @@ var ts;
     ts.forEach = forEach;
     function contains(array, value) {
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+                var v = array_1[_i];
                 if (v === value) {
                     return true;
                 }
@@ -921,8 +940,8 @@ var ts;
     function countWhere(array, predicate) {
         var count = 0;
         if (array) {
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_2 = array; _i < array_2.length; _i++) {
+                var v = array_2[_i];
                 if (predicate(v)) {
                     count++;
                 }
@@ -935,8 +954,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_3 = array; _i < array_3.length; _i++) {
+                var item = array_3[_i];
                 if (f(item)) {
                     result.push(item);
                 }
@@ -949,8 +968,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var v = array[_i];
+            for (var _i = 0, array_4 = array; _i < array_4.length; _i++) {
+                var v = array_4[_i];
                 result.push(f(v));
             }
         }
@@ -969,8 +988,8 @@ var ts;
         var result;
         if (array) {
             result = [];
-            for (var _i = 0; _i < array.length; _i++) {
-                var item = array[_i];
+            for (var _i = 0, array_5 = array; _i < array_5.length; _i++) {
+                var item = array_5[_i];
                 if (!contains(result, item)) {
                     result.push(item);
                 }
@@ -981,8 +1000,8 @@ var ts;
     ts.deduplicate = deduplicate;
     function sum(array, prop) {
         var result = 0;
-        for (var _i = 0; _i < array.length; _i++) {
-            var v = array[_i];
+        for (var _i = 0, array_6 = array; _i < array_6.length; _i++) {
+            var v = array_6[_i];
             result += v[prop];
         }
         return result;
@@ -990,8 +1009,8 @@ var ts;
     ts.sum = sum;
     function addRange(to, from) {
         if (to && from) {
-            for (var _i = 0; _i < from.length; _i++) {
-                var v = from[_i];
+            for (var _i = 0, from_1 = from; _i < from_1.length; _i++) {
+                var v = from_1[_i];
                 to.push(v);
             }
         }
@@ -1341,8 +1360,8 @@ var ts;
     function getNormalizedParts(normalizedSlashedPath, rootLength) {
         var parts = normalizedSlashedPath.substr(rootLength).split(ts.directorySeparator);
         var normalized = [];
-        for (var _i = 0; _i < parts.length; _i++) {
-            var part = parts[_i];
+        for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+            var part = parts_1[_i];
             if (part !== ".") {
                 if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
@@ -1521,8 +1540,8 @@ var ts;
         if (!fileName) {
             return false;
         }
-        for (var _i = 0; _i < ts.supportedExtensions.length; _i++) {
-            var extension = ts.supportedExtensions[_i];
+        for (var _i = 0, supportedExtensions_1 = ts.supportedExtensions; _i < supportedExtensions_1.length; _i++) {
+            var extension = supportedExtensions_1[_i];
             if (fileExtensionIs(fileName, extension)) {
                 return true;
             }
@@ -1532,8 +1551,8 @@ var ts;
     ts.isSupportedSourceFileName = isSupportedSourceFileName;
     var extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     function removeFileExtension(path) {
-        for (var _i = 0; _i < extensionsToRemove.length; _i++) {
-            var ext = extensionsToRemove[_i];
+        for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) {
+            var ext = extensionsToRemove_1[_i];
             if (fileExtensionIs(path, ext)) {
                 return path.substr(0, path.length - ext.length);
             }
@@ -1614,8 +1633,8 @@ var ts;
     })(Debug = ts.Debug || (ts.Debug = {}));
     function copyListRemovingItem(item, list) {
         var copiedList = [];
-        for (var _i = 0; _i < list.length; _i++) {
-            var e = list[_i];
+        for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+            var e = list_1[_i];
             if (e !== item) {
                 copiedList.push(e);
             }
@@ -1709,16 +1728,16 @@ var ts;
                 function visitDirectory(path) {
                     var folder = fso.GetFolder(path || ".");
                     var files = getNames(folder.files);
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        var current = files_1[_i];
                         var name_1 = ts.combinePaths(path, current);
                         if ((!extension || ts.fileExtensionIs(name_1, extension)) && !ts.contains(exclude, getCanonicalPath(name_1))) {
                             result.push(name_1);
                         }
                     }
                     var subfolders = getNames(folder.subfolders);
-                    for (var _a = 0; _a < subfolders.length; _a++) {
-                        var current = subfolders[_a];
+                    for (var _a = 0, subfolders_1 = subfolders; _a < subfolders_1.length; _a++) {
+                        var current = subfolders_1[_a];
                         var name_2 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_2))) {
                             visitDirectory(name_2);
@@ -1769,6 +1788,7 @@ var ts;
             var _fs = require("fs");
             var _path = require("path");
             var _os = require("os");
+            var _tty = require("tty");
             // average async stat takes about 30 microseconds
             // set chunk size to do 30 files in < 1 millisecond
             function createWatchedFileSet(interval, chunkSize) {
@@ -1906,8 +1926,8 @@ var ts;
                 function visitDirectory(path) {
                     var files = _fs.readdirSync(path || ".").sort();
                     var directories = [];
-                    for (var _i = 0; _i < files.length; _i++) {
-                        var current = files[_i];
+                    for (var _i = 0, files_2 = files; _i < files_2.length; _i++) {
+                        var current = files_2[_i];
                         var name_3 = ts.combinePaths(path, current);
                         if (!ts.contains(exclude, getCanonicalPath(name_3))) {
                             var stat = _fs.statSync(name_3);
@@ -1921,8 +1941,8 @@ var ts;
                             }
                         }
                     }
-                    for (var _a = 0; _a < directories.length; _a++) {
-                        var current = directories[_a];
+                    for (var _a = 0, directories_1 = directories; _a < directories_1.length; _a++) {
+                        var current = directories_1[_a];
                         visitDirectory(current);
                     }
                 }
@@ -1932,15 +1952,7 @@ var ts;
                 newLine: _os.EOL,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 write: function (s) {
-                    var buffer = new Buffer(s, "utf8");
-                    var offset = 0;
-                    var toWrite = buffer.length;
-                    var written = 0;
-                    // 1 is a standard descriptor for stdout
-                    while ((written = _fs.writeSync(1, buffer, offset, toWrite)) < toWrite) {
-                        offset += written;
-                        toWrite -= written;
-                    }
+                    process.stdout.write(s);
                 },
                 readFile: readFile,
                 writeFile: writeFile,
@@ -2223,6 +2235,7 @@ var ts;
         await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: ts.DiagnosticCategory.Error, key: "await_expression_is_only_allowed_within_an_async_function_1308", message: "'await' expression is only allowed within an async function." },
         Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: ts.DiagnosticCategory.Error, key: "Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher_1311", message: "Async functions are only available when targeting ECMAScript 6 and higher." },
         can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: { code: 1312, category: ts.DiagnosticCategory.Error, key: "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", message: "'=' can only be used in an object literal property inside a destructuring assignment." },
+        The_body_of_an_if_statement_cannot_be_the_empty_statement: { code: 1313, category: ts.DiagnosticCategory.Error, key: "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", message: "The body of an 'if' statement cannot be the empty statement." },
         Duplicate_identifier_0: { code: 2300, category: ts.DiagnosticCategory.Error, key: "Duplicate_identifier_0_2300", message: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: ts.DiagnosticCategory.Error, key: "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", message: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: ts.DiagnosticCategory.Error, key: "Static_members_cannot_reference_class_type_parameters_2302", message: "Static members cannot reference class type parameters." },
@@ -2275,7 +2288,7 @@ var ts;
         Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: ts.DiagnosticCategory.Error, key: "Neither_type_0_nor_type_1_is_assignable_to_the_other_2352", message: "Neither type '{0}' nor type '{1}' is assignable to the other." },
         Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: ts.DiagnosticCategory.Error, key: "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", message: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
         No_best_common_type_exists_among_return_expressions: { code: 2354, category: ts.DiagnosticCategory.Error, key: "No_best_common_type_exists_among_return_expressions_2354", message: "No best common type exists among return expressions." },
-        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_th_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." },
+        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: { code: 2355, category: ts.DiagnosticCategory.Error, key: "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", message: "A function whose declared type is neither 'void' nor 'any' must return a value." },
         An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: ts.DiagnosticCategory.Error, key: "An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type_2356", message: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
         The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: ts.DiagnosticCategory.Error, key: "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer_2357", message: "The operand of an increment or decrement operator must be a variable, property or indexer." },
         The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: ts.DiagnosticCategory.Error, key: "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", message: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." },
@@ -2296,7 +2309,7 @@ var ts;
         Duplicate_number_index_signature: { code: 2375, category: ts.DiagnosticCategory.Error, key: "Duplicate_number_index_signature_2375", message: "Duplicate number index signature." },
         A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: ts.DiagnosticCategory.Error, key: "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", message: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." },
         Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: ts.DiagnosticCategory.Error, key: "Constructors_for_derived_classes_must_contain_a_super_call_2377", message: "Constructors for derived classes must contain a 'super' call." },
-        A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement_2378", message: "A 'get' accessor must return a value or consist of a single 'throw' statement." },
+        A_get_accessor_must_return_a_value: { code: 2378, category: ts.DiagnosticCategory.Error, key: "A_get_accessor_must_return_a_value_2378", message: "A 'get' accessor must return a value." },
         Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: ts.DiagnosticCategory.Error, key: "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", message: "Getter and setter accessors do not agree in visibility." },
         get_and_set_accessor_must_have_the_same_type: { code: 2380, category: ts.DiagnosticCategory.Error, key: "get_and_set_accessor_must_have_the_same_type_2380", message: "'get' and 'set' accessor must have the same type." },
         A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: ts.DiagnosticCategory.Error, key: "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", message: "A signature with an implementation cannot use a string literal type." },
@@ -2586,8 +2599,6 @@ var ts;
         NEWLINE: { code: 6061, category: ts.DiagnosticCategory.Message, key: "NEWLINE_6061", message: "NEWLINE" },
         Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: ts.DiagnosticCategory.Error, key: "Argument_for_newLine_option_must_be_CRLF_or_LF_6062", message: "Argument for '--newLine' option must be 'CRLF' or 'LF'." },
         Argument_for_moduleResolution_option_must_be_node_or_classic: { code: 6063, category: ts.DiagnosticCategory.Error, key: "Argument_for_moduleResolution_option_must_be_node_or_classic_6063", message: "Argument for '--moduleResolution' option must be 'node' or 'classic'." },
-        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
-        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Enables_experimental_support_for_ES7_decorators: { code: 6065, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_decorators_6065", message: "Enables experimental support for ES7 decorators." },
         Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", message: "Enables experimental support for emitting type metadata for decorators." },
         Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: ts.DiagnosticCategory.Message, key: "Enables_experimental_support_for_ES7_async_functions_6068", message: "Enables experimental support for ES7 async functions." },
@@ -2595,7 +2606,14 @@ var ts;
         Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: ts.DiagnosticCategory.Message, key: "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", message: "Initializes a TypeScript project and creates a tsconfig.json file." },
         Successfully_created_a_tsconfig_json_file: { code: 6071, category: ts.DiagnosticCategory.Message, key: "Successfully_created_a_tsconfig_json_file_6071", message: "Successfully created a tsconfig.json file." },
         Suppress_excess_property_checks_for_object_literals: { code: 6072, category: ts.DiagnosticCategory.Message, key: "Suppress_excess_property_checks_for_object_literals_6072", message: "Suppress excess property checks for object literals." },
-        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6073", message: "Disallow inconsistently-cased references to the same file." },
+        Stylize_errors_and_messages_using_color_and_context_experimental: { code: 6073, category: ts.DiagnosticCategory.Message, key: "Stylize_errors_and_messages_using_color_and_context_experimental_6073", message: "Stylize errors and messages using color and context. (experimental)" },
+        Do_not_report_errors_on_unused_labels: { code: 6074, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unused_labels_6074", message: "Do not report errors on unused labels." },
+        Report_error_when_not_all_code_paths_in_function_return_a_value: { code: 6075, category: ts.DiagnosticCategory.Message, key: "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", message: "Report error when not all code paths in function return a value." },
+        Report_errors_for_fallthrough_cases_in_switch_statement: { code: 6076, category: ts.DiagnosticCategory.Message, key: "Report_errors_for_fallthrough_cases_in_switch_statement_6076", message: "Report errors for fallthrough cases in switch statement." },
+        Do_not_report_errors_on_unreachable_code: { code: 6077, category: ts.DiagnosticCategory.Message, key: "Do_not_report_errors_on_unreachable_code_6077", message: "Do not report errors on unreachable code." },
+        Disallow_inconsistently_cased_references_to_the_same_file: { code: 6078, category: ts.DiagnosticCategory.Message, key: "Disallow_inconsistently_cased_references_to_the_same_file_6078", message: "Disallow inconsistently-cased references to the same file." },
+        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: ts.DiagnosticCategory.Message, key: "Specify_JSX_code_generation_Colon_preserve_or_react_6080", message: "Specify JSX code generation: 'preserve' or 'react'" },
+        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: ts.DiagnosticCategory.Message, key: "Argument_for_jsx_must_be_preserve_or_react_6081", message: "Argument for '--jsx' must be 'preserve' or 'react'." },
         Variable_0_implicitly_has_an_1_type: { code: 7005, category: ts.DiagnosticCategory.Error, key: "Variable_0_implicitly_has_an_1_type_7005", message: "Variable '{0}' implicitly has an '{1}' type." },
         Parameter_0_implicitly_has_an_1_type: { code: 7006, category: ts.DiagnosticCategory.Error, key: "Parameter_0_implicitly_has_an_1_type_7006", message: "Parameter '{0}' implicitly has an '{1}' type." },
         Member_0_implicitly_has_an_1_type: { code: 7008, category: ts.DiagnosticCategory.Error, key: "Member_0_implicitly_has_an_1_type_7008", message: "Member '{0}' implicitly has an '{1}' type." },
@@ -2613,6 +2631,10 @@ var ts;
         Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: ts.DiagnosticCategory.Error, key: "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", message: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
         Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: ts.DiagnosticCategory.Error, key: "Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_typ_7025", message: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
         JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: ts.DiagnosticCategory.Error, key: "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", message: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
+        Unreachable_code_detected: { code: 7027, category: ts.DiagnosticCategory.Error, key: "Unreachable_code_detected_7027", message: "Unreachable code detected." },
+        Unused_label: { code: 7028, category: ts.DiagnosticCategory.Error, key: "Unused_label_7028", message: "Unused label." },
+        Fallthrough_case_in_switch: { code: 7029, category: ts.DiagnosticCategory.Error, key: "Fallthrough_case_in_switch_7029", message: "Fallthrough case in switch." },
+        Not_all_code_paths_return_a_value: { code: 7030, category: ts.DiagnosticCategory.Error, key: "Not_all_code_paths_return_a_value_7030", message: "Not all code paths return a value." },
         You_cannot_rename_this_element: { code: 8000, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_this_element_8000", message: "You cannot rename this element." },
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: ts.DiagnosticCategory.Error, key: "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", message: "You cannot rename elements that are defined in the standard TypeScript library." },
         import_can_only_be_used_in_a_ts_file: { code: 8002, category: ts.DiagnosticCategory.Error, key: "import_can_only_be_used_in_a_ts_file_8002", message: "'import ... =' can only be used in a .ts file." },
@@ -4166,6 +4188,20 @@ var ts;
         ModuleInstanceState[ModuleInstanceState["ConstEnumOnly"] = 2] = "ConstEnumOnly";
     })(ts.ModuleInstanceState || (ts.ModuleInstanceState = {}));
     var ModuleInstanceState = ts.ModuleInstanceState;
+    var Reachability;
+    (function (Reachability) {
+        Reachability[Reachability["Unintialized"] = 1] = "Unintialized";
+        Reachability[Reachability["Reachable"] = 2] = "Reachable";
+        Reachability[Reachability["Unreachable"] = 4] = "Unreachable";
+        Reachability[Reachability["ReportedUnreachable"] = 8] = "ReportedUnreachable";
+    })(Reachability || (Reachability = {}));
+    function or(state1, state2) {
+        return (state1 | state2) & 2 /* Reachable */
+            ? 2 /* Reachable */
+            : (state1 & state2) & 8 /* ReportedUnreachable */
+                ? 8 /* ReportedUnreachable */
+                : 4 /* Unreachable */;
+    }
     function getModuleInstanceState(node) {
         // A module is uninstantiated if it contains only
         // 1. interface declarations, type alias declarations
@@ -4175,7 +4211,7 @@ var ts;
         else if (ts.isConstEnumDeclaration(node)) {
             return 2 /* ConstEnumOnly */;
         }
-        else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && !(node.flags & 1 /* Export */)) {
+        else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && !(node.flags & 2 /* Export */)) {
             return 0 /* NonInstantiated */;
         }
         else if (node.kind === 219 /* ModuleBlock */) {
@@ -4226,31 +4262,56 @@ var ts;
         //      Functions, Methods, Modules, Source-files.
         ContainerFlags[ContainerFlags["IsContainerWithLocals"] = 5] = "IsContainerWithLocals";
     })(ContainerFlags || (ContainerFlags = {}));
-    function bindSourceFile(file) {
+    var binder = createBinder();
+    function bindSourceFile(file, options) {
         var start = new Date().getTime();
-        bindSourceFileWorker(file);
+        binder(file, options);
         ts.bindTime += new Date().getTime() - start;
     }
     ts.bindSourceFile = bindSourceFile;
-    function bindSourceFileWorker(file) {
+    function createBinder() {
+        var file;
+        var options;
         var parent;
         var container;
         var blockScopeContainer;
         var lastContainer;
         var seenThisKeyword;
+        // state used by reachability checks
+        var hasExplicitReturn;
+        var currentReachabilityState;
+        var labelStack;
+        var labelIndexMap;
+        var implicitLabels;
         // If this file is an external module, then it is automatically in strict-mode according to
         // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
         // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
-        var inStrictMode = !!file.externalModuleIndicator;
+        var inStrictMode;
         var symbolCount = 0;
-        var Symbol = ts.objectAllocator.getSymbolConstructor();
-        var classifiableNames = {};
-        if (!file.locals) {
-            bind(file);
-            file.symbolCount = symbolCount;
-            file.classifiableNames = classifiableNames;
+        var Symbol;
+        var classifiableNames;
+        function bindSourceFile(f, opts) {
+            file = f;
+            options = opts;
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            Symbol = ts.objectAllocator.getSymbolConstructor();
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            hasExplicitReturn = false;
+            labelStack = undefined;
+            labelIndexMap = undefined;
+            implicitLabels = undefined;
         }
-        return;
+        return bindSourceFile;
         function createSymbol(flags, name) {
             symbolCount++;
             return new Symbol(flags, name);
@@ -4303,7 +4364,7 @@ var ts;
                     return node.isExportEquals ? "export=" : "default";
                 case 213 /* FunctionDeclaration */:
                 case 214 /* ClassDeclaration */:
-                    return node.flags & 1024 /* Default */ ? "default" : undefined;
+                    return node.flags & 512 /* Default */ ? "default" : undefined;
             }
         }
         function getDisplayName(node) {
@@ -4319,7 +4380,7 @@ var ts;
          */
         function declareSymbol(symbolTable, parent, node, includes, excludes) {
             ts.Debug.assert(!ts.hasDynamicName(node));
-            var isDefaultExport = node.flags & 1024 /* Default */;
+            var isDefaultExport = node.flags & 512 /* Default */;
             // The exported symbol for an export default function/class node is always named "default"
             var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
             var symbol;
@@ -4358,7 +4419,7 @@ var ts;
                         ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : ts.Diagnostics.Duplicate_identifier_0;
                     ts.forEach(symbol.declarations, function (declaration) {
-                        if (declaration.flags & 1024 /* Default */) {
+                        if (declaration.flags & 512 /* Default */) {
                             message = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
                         }
                     });
@@ -4377,7 +4438,7 @@ var ts;
             return symbol;
         }
         function declareModuleMember(node, symbolFlags, symbolExcludes) {
-            var hasExportModifier = ts.getCombinedNodeFlags(node) & 1 /* Export */;
+            var hasExportModifier = ts.getCombinedNodeFlags(node) & 2 /* Export */;
             if (symbolFlags & 8388608 /* Alias */) {
                 if (node.kind === 230 /* ExportSpecifier */ || (node.kind === 221 /* ImportEqualsDeclaration */ && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -4398,7 +4459,7 @@ var ts;
                 //   2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol,
                 //      but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way
                 //      when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.
-                if (hasExportModifier || container.flags & 262144 /* ExportContext */) {
+                if (hasExportModifier || container.flags & 131072 /* ExportContext */) {
                     var exportKind = (symbolFlags & 107455 /* Value */ ? 1048576 /* ExportValue */ : 0) |
                         (symbolFlags & 793056 /* Type */ ? 2097152 /* ExportType */ : 0) |
                         (symbolFlags & 1536 /* Namespace */ ? 4194304 /* ExportNamespace */ : 0);
@@ -4453,18 +4514,229 @@ var ts;
                 blockScopeContainer = node;
                 blockScopeContainer.locals = undefined;
             }
-            if (node.kind === 215 /* InterfaceDeclaration */) {
+            var savedReachabilityState;
+            var savedLabelStack;
+            var savedLabels;
+            var savedImplicitLabels;
+            var savedHasExplicitReturn;
+            var kind = node.kind;
+            var flags = node.flags;
+            // reset all reachability check related flags on node (for incremental scenarios)
+            flags &= ~1572864 /* ReachabilityCheckFlags */;
+            if (kind === 215 /* InterfaceDeclaration */) {
                 seenThisKeyword = false;
-                ts.forEachChild(node, bind);
-                node.flags = seenThisKeyword ? node.flags | 524288 /* ContainsThis */ : node.flags & ~524288 /* ContainsThis */;
             }
-            else {
-                ts.forEachChild(node, bind);
+            var saveState = kind === 248 /* SourceFile */ || kind === 219 /* ModuleBlock */ || ts.isFunctionLikeKind(kind);
+            if (saveState) {
+                savedReachabilityState = currentReachabilityState;
+                savedLabelStack = labelStack;
+                savedLabels = labelIndexMap;
+                savedImplicitLabels = implicitLabels;
+                savedHasExplicitReturn = hasExplicitReturn;
+                currentReachabilityState = 2 /* Reachable */;
+                hasExplicitReturn = false;
+                labelStack = labelIndexMap = implicitLabels = undefined;
+            }
+            bindReachableStatement(node);
+            if (currentReachabilityState === 2 /* Reachable */ && ts.isFunctionLikeKind(kind) && ts.nodeIsPresent(node.body)) {
+                flags |= 524288 /* HasImplicitReturn */;
+                if (hasExplicitReturn) {
+                    flags |= 1048576 /* HasExplicitReturn */;
+                }
+            }
+            if (kind === 215 /* InterfaceDeclaration */) {
+                flags = seenThisKeyword ? flags | 262144 /* ContainsThis */ : flags & ~262144 /* ContainsThis */;
+            }
+            node.flags = flags;
+            if (saveState) {
+                hasExplicitReturn = savedHasExplicitReturn;
+                currentReachabilityState = savedReachabilityState;
+                labelStack = savedLabelStack;
+                labelIndexMap = savedLabels;
+                implicitLabels = savedImplicitLabels;
             }
             container = saveContainer;
             parent = saveParent;
             blockScopeContainer = savedBlockScopeContainer;
         }
+        /**
+         * Returns true if node and its subnodes were successfully traversed.
+         * Returning false means that node was not examined and caller needs to dive into the node himself.
+         */
+        function bindReachableStatement(node) {
+            if (checkUnreachable(node)) {
+                ts.forEachChild(node, bind);
+                return;
+            }
+            switch (node.kind) {
+                case 198 /* WhileStatement */:
+                    bindWhileStatement(node);
+                    break;
+                case 197 /* DoStatement */:
+                    bindDoStatement(node);
+                    break;
+                case 199 /* ForStatement */:
+                    bindForStatement(node);
+                    break;
+                case 200 /* ForInStatement */:
+                case 201 /* ForOfStatement */:
+                    bindForInOrForOfStatement(node);
+                    break;
+                case 196 /* IfStatement */:
+                    bindIfStatement(node);
+                    break;
+                case 204 /* ReturnStatement */:
+                case 208 /* ThrowStatement */:
+                    bindReturnOrThrow(node);
+                    break;
+                case 203 /* BreakStatement */:
+                case 202 /* ContinueStatement */:
+                    bindBreakOrContinueStatement(node);
+                    break;
+                case 209 /* TryStatement */:
+                    bindTryStatement(node);
+                    break;
+                case 206 /* SwitchStatement */:
+                    bindSwitchStatement(node);
+                    break;
+                case 220 /* CaseBlock */:
+                    bindCaseBlock(node);
+                    break;
+                case 207 /* LabeledStatement */:
+                    bindLabeledStatement(node);
+                    break;
+                default:
+                    ts.forEachChild(node, bind);
+                    break;
+            }
+        }
+        function bindWhileStatement(n) {
+            var preWhileState = n.expression.kind === 84 /* FalseKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            var postWhileState = n.expression.kind === 99 /* TrueKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+            currentReachabilityState = preWhileState;
+            var postWhileLabel = pushImplicitLabel();
+            bind(n.statement);
+            popImplicitLabel(postWhileLabel, postWhileState);
+        }
+        function bindDoStatement(n) {
+            var preDoState = currentReachabilityState;
+            var postDoLabel = pushImplicitLabel();
+            bind(n.statement);
+            var postDoState = n.expression.kind === 99 /* TrueKeyword */ ? 4 /* Unreachable */ : preDoState;
+            popImplicitLabel(postDoLabel, postDoState);
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+        }
+        function bindForStatement(n) {
+            var preForState = currentReachabilityState;
+            var postForLabel = pushImplicitLabel();
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.condition);
+            bind(n.incrementor);
+            bind(n.statement);
+            // for statement is considered infinite when it condition is either omitted or is true keyword
+            // - for(..;;..)
+            // - for(..;true;..)
+            var isInfiniteLoop = (!n.condition || n.condition.kind === 99 /* TrueKeyword */);
+            var postForState = isInfiniteLoop ? 4 /* Unreachable */ : preForState;
+            popImplicitLabel(postForLabel, postForState);
+        }
+        function bindForInOrForOfStatement(n) {
+            var preStatementState = currentReachabilityState;
+            var postStatementLabel = pushImplicitLabel();
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.expression);
+            bind(n.statement);
+            popImplicitLabel(postStatementLabel, preStatementState);
+        }
+        function bindIfStatement(n) {
+            // denotes reachability state when entering 'thenStatement' part of the if statement: 
+            // i.e. if condition is false then thenStatement is unreachable
+            var ifTrueState = n.expression.kind === 84 /* FalseKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            // denotes reachability state when entering 'elseStatement':
+            // i.e. if condition is true then elseStatement is unreachable
+            var ifFalseState = n.expression.kind === 99 /* TrueKeyword */ ? 4 /* Unreachable */ : currentReachabilityState;
+            currentReachabilityState = ifTrueState;
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            bind(n.thenStatement);
+            if (n.elseStatement) {
+                var preElseState = currentReachabilityState;
+                currentReachabilityState = ifFalseState;
+                bind(n.elseStatement);
+                currentReachabilityState = or(currentReachabilityState, preElseState);
+            }
+            else {
+                currentReachabilityState = or(currentReachabilityState, ifFalseState);
+            }
+        }
+        function bindReturnOrThrow(n) {
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            if (n.kind === 204 /* ReturnStatement */) {
+                hasExplicitReturn = true;
+            }
+            currentReachabilityState = 4 /* Unreachable */;
+        }
+        function bindBreakOrContinueStatement(n) {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+            // for continue case touch label so it will be marked a used
+            var isValidJump = jumpToLabel(n.label, n.kind === 203 /* BreakStatement */ ? currentReachabilityState : 4 /* Unreachable */);
+            if (isValidJump) {
+                currentReachabilityState = 4 /* Unreachable */;
+            }
+        }
+        function bindTryStatement(n) {
+            // catch\finally blocks has the same reachability as try block
+            var preTryState = currentReachabilityState;
+            bind(n.tryBlock);
+            var postTryState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.catchClause);
+            var postCatchState = currentReachabilityState;
+            currentReachabilityState = preTryState;
+            bind(n.finallyBlock);
+            // post catch/finally state is reachable if
+            // - post try state is reachable - control flow can fall out of try block
+            // - post catch state is reachable - control flow can fall out of catch block
+            currentReachabilityState = or(postTryState, postCatchState);
+        }
+        function bindSwitchStatement(n) {
+            var preSwitchState = currentReachabilityState;
+            var postSwitchLabel = pushImplicitLabel();
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            bind(n.caseBlock);
+            var hasDefault = ts.forEach(n.caseBlock.clauses, function (c) { return c.kind === 242 /* DefaultClause */; });
+            // post switch state is unreachable if switch is exaustive (has a default case ) and does not have fallthrough from the last case
+            var postSwitchState = hasDefault && currentReachabilityState !== 2 /* Reachable */ ? 4 /* Unreachable */ : preSwitchState;
+            popImplicitLabel(postSwitchLabel, postSwitchState);
+        }
+        function bindCaseBlock(n) {
+            var startState = currentReachabilityState;
+            for (var _i = 0, _a = n.clauses; _i < _a.length; _i++) {
+                var clause = _a[_i];
+                currentReachabilityState = startState;
+                bind(clause);
+                if (clause.statements.length && currentReachabilityState === 2 /* Reachable */ && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, ts.Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+        function bindLabeledStatement(n) {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+            var ok = pushNamedLabel(n.label);
+            bind(n.statement);
+            if (ok) {
+                popNamedLabel(n.label, currentReachabilityState);
+            }
+        }
         function getContainerFlags(node) {
             switch (node.kind) {
                 case 186 /* ClassExpression */:
@@ -4576,7 +4848,7 @@ var ts;
             }
         }
         function declareClassMember(node, symbolFlags, symbolExcludes) {
-            return node.flags & 128 /* Static */
+            return node.flags & 64 /* Static */
                 ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
                 : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
         }
@@ -4585,15 +4857,6 @@ var ts;
                 ? declareModuleMember(node, symbolFlags, symbolExcludes)
                 : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
         }
-        function isAmbientContext(node) {
-            while (node) {
-                if (node.flags & 2 /* Ambient */) {
-                    return true;
-                }
-                node = node.parent;
-            }
-            return false;
-        }
         function hasExportDeclarations(node) {
             var body = node.kind === 248 /* SourceFile */ ? node : node.body;
             if (body.kind === 248 /* SourceFile */ || body.kind === 219 /* ModuleBlock */) {
@@ -4609,11 +4872,11 @@ var ts;
         function setExportContextFlag(node) {
             // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular
             // declarations with export modifiers) is an export context in which declarations are implicitly exported.
-            if (isAmbientContext(node) && !hasExportDeclarations(node)) {
-                node.flags |= 262144 /* ExportContext */;
+            if (ts.isInAmbientContext(node) && !hasExportDeclarations(node)) {
+                node.flags |= 131072 /* ExportContext */;
             }
             else {
-                node.flags &= ~262144 /* ExportContext */;
+                node.flags &= ~131072 /* ExportContext */;
             }
         }
         function bindModuleDeclaration(node) {
@@ -4805,7 +5068,7 @@ var ts;
             }
         }
         function checkStrictModeNumericLiteral(node) {
-            if (inStrictMode && node.flags & 65536 /* OctalLiteral */) {
+            if (inStrictMode && node.flags & 32768 /* OctalLiteral */) {
                 file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
         }
@@ -4829,10 +5092,10 @@ var ts;
         function checkStrictModeWithStatement(node) {
             // Grammar checking for withStatement
             if (inStrictMode) {
-                grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
             }
         }
-        function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+        function errorOnFirstToken(node, message, arg0, arg1, arg2) {
             var span = ts.getSpanOfTokenAtPosition(file, node.pos);
             file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
         }
@@ -4840,6 +5103,9 @@ var ts;
             return "__" + ts.indexOf(node.parent.parameters, node);
         }
         function bind(node) {
+            if (!node) {
+                return;
+            }
             node.parent = parent;
             var savedInStrictMode = inStrictMode;
             if (!savedInStrictMode) {
@@ -4882,8 +5148,8 @@ var ts;
             }
         }
         function updateStrictModeStatementList(statements) {
-            for (var _i = 0; _i < statements.length; _i++) {
-                var statement = statements[_i];
+            for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
+                var statement = statements_1[_i];
                 if (!ts.isPrologueDirective(statement)) {
                     return;
                 }
@@ -5105,7 +5371,7 @@ var ts;
             }
             // If this is a property-parameter, then also declare the property symbol into the
             // containing class.
-            if (node.flags & 112 /* AccessibilityModifier */ &&
+            if (node.flags & 56 /* AccessibilityModifier */ &&
                 node.parent.kind === 144 /* Constructor */ &&
                 ts.isClassLike(node.parent.parent)) {
                 var classDeclaration = node.parent.parent;
@@ -5117,6 +5383,112 @@ var ts;
                 ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
+        // reachability checks
+        function pushNamedLabel(name) {
+            initializeReachabilityStateIfNecessary();
+            if (ts.hasProperty(labelIndexMap, name.text)) {
+                return false;
+            }
+            labelIndexMap[name.text] = labelStack.push(1 /* Unintialized */) - 1;
+            return true;
+        }
+        function pushImplicitLabel() {
+            initializeReachabilityStateIfNecessary();
+            var index = labelStack.push(1 /* Unintialized */) - 1;
+            implicitLabels.push(index);
+            return index;
+        }
+        function popNamedLabel(label, outerState) {
+            var index = labelIndexMap[label.text];
+            ts.Debug.assert(index !== undefined);
+            ts.Debug.assert(labelStack.length == index + 1);
+            labelIndexMap[label.text] = undefined;
+            setCurrentStateAtLabel(labelStack.pop(), outerState, label);
+        }
+        function popImplicitLabel(implicitLabelIndex, outerState) {
+            if (labelStack.length !== implicitLabelIndex + 1) {
+                ts.Debug.assert(false, "Label stack: " + labelStack.length + ", index:" + implicitLabelIndex);
+            }
+            var i = implicitLabels.pop();
+            if (implicitLabelIndex !== i) {
+                ts.Debug.assert(false, "i: " + i + ", index: " + implicitLabelIndex);
+            }
+            setCurrentStateAtLabel(labelStack.pop(), outerState, /*name*/ undefined);
+        }
+        function setCurrentStateAtLabel(innerMergedState, outerState, label) {
+            if (innerMergedState === 1 /* Unintialized */) {
+                if (label && !options.allowUnusedLabels) {
+                    file.bindDiagnostics.push(ts.createDiagnosticForNode(label, ts.Diagnostics.Unused_label));
+                }
+                currentReachabilityState = outerState;
+            }
+            else {
+                currentReachabilityState = or(innerMergedState, outerState);
+            }
+        }
+        function jumpToLabel(label, outerState) {
+            initializeReachabilityStateIfNecessary();
+            var index = label ? labelIndexMap[label.text] : ts.lastOrUndefined(implicitLabels);
+            if (index === undefined) {
+                // reference to unknown label or
+                // break/continue used outside of loops
+                return false;
+            }
+            var stateAtLabel = labelStack[index];
+            labelStack[index] = stateAtLabel === 1 /* Unintialized */ ? outerState : or(stateAtLabel, outerState);
+            return true;
+        }
+        function checkUnreachable(node) {
+            switch (currentReachabilityState) {
+                case 4 /* Unreachable */:
+                    var reportError = 
+                    // report error on all statements
+                    ts.isStatement(node) ||
+                        // report error on class declarations
+                        node.kind === 214 /* ClassDeclaration */ ||
+                        // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+                        (node.kind === 218 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)) ||
+                        // report error on regular enums and const enums if preserveConstEnums is set
+                        (node.kind === 217 /* EnumDeclaration */ && (!ts.isConstEnumDeclaration(node) || options.preserveConstEnums));
+                    if (reportError) {
+                        currentReachabilityState = 8 /* ReportedUnreachable */;
+                        // unreachable code is reported if
+                        // - user has explicitly asked about it AND
+                        // - statement is in not ambient context (statements in ambient context is already an error 
+                        //   so we should not report extras) AND
+                        //   - node is not variable statement OR
+                        //   - node is block scoped variable statement OR
+                        //   - node is not block scoped variable statement and at least one variable declaration has initializer
+                        //   Rationale: we don't want to report errors on non-initialized var's since they are hoisted
+                        //   On the other side we do want to report errors on non-initialized 'lets' because of TDZ
+                        var reportUnreachableCode = !options.allowUnreachableCode &&
+                            !ts.isInAmbientContext(node) &&
+                            (node.kind !== 193 /* VariableStatement */ ||
+                                ts.getCombinedNodeFlags(node.declarationList) & 24576 /* BlockScoped */ ||
+                                ts.forEach(node.declarationList.declarations, function (d) { return d.initializer; }));
+                        if (reportUnreachableCode) {
+                            errorOnFirstToken(node, ts.Diagnostics.Unreachable_code_detected);
+                        }
+                    }
+                case 8 /* ReportedUnreachable */:
+                    return true;
+                default:
+                    return false;
+            }
+            function shouldReportErrorOnModuleDeclaration(node) {
+                var instanceState = getModuleInstanceState(node);
+                return instanceState === 1 /* Instantiated */ || (instanceState === 2 /* ConstEnumOnly */ && options.preserveConstEnums);
+            }
+        }
+        function initializeReachabilityStateIfNecessary() {
+            if (labelIndexMap) {
+                return;
+            }
+            currentReachabilityState = 2 /* Reachable */;
+            labelIndexMap = {};
+            labelStack = [];
+            implicitLabels = [];
+        }
     }
 })(ts || (ts = {}));
 /// <reference path="binder.ts" />
@@ -5127,8 +5499,8 @@ var ts;
     function getDeclarationOfKind(symbol, kind) {
         var declarations = symbol.declarations;
         if (declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) {
+                var declaration = declarations_1[_i];
                 if (declaration.kind === kind) {
                     return declaration;
                 }
@@ -5328,7 +5700,7 @@ var ts;
     }
     ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName;
     function isBlockOrCatchScoped(declaration) {
-        return (getCombinedNodeFlags(declaration) & 49152 /* BlockScoped */) !== 0 ||
+        return (getCombinedNodeFlags(declaration) & 24576 /* BlockScoped */) !== 0 ||
             isCatchClauseVariableDeclaration(declaration);
     }
     ts.isBlockOrCatchScoped = isBlockOrCatchScoped;
@@ -5441,7 +5813,7 @@ var ts;
     }
     ts.isExternalModule = isExternalModule;
     function isDeclarationFile(file) {
-        return (file.flags & 8192 /* DeclarationFile */) !== 0;
+        return (file.flags & 4096 /* DeclarationFile */) !== 0;
     }
     ts.isDeclarationFile = isDeclarationFile;
     function isConstEnumDeclaration(node) {
@@ -5478,11 +5850,11 @@ var ts;
     }
     ts.getCombinedNodeFlags = getCombinedNodeFlags;
     function isConst(node) {
-        return !!(getCombinedNodeFlags(node) & 32768 /* Const */);
+        return !!(getCombinedNodeFlags(node) & 16384 /* Const */);
     }
     ts.isConst = isConst;
     function isLet(node) {
-        return !!(getCombinedNodeFlags(node) & 16384 /* Let */);
+        return !!(getCombinedNodeFlags(node) & 8192 /* Let */);
     }
     ts.isLet = isLet;
     function isPrologueDirective(node) {
@@ -5683,27 +6055,28 @@ var ts;
     }
     ts.isClassLike = isClassLike;
     function isFunctionLike(node) {
-        if (node) {
-            switch (node.kind) {
-                case 144 /* Constructor */:
-                case 173 /* FunctionExpression */:
-                case 213 /* FunctionDeclaration */:
-                case 174 /* ArrowFunction */:
-                case 143 /* MethodDeclaration */:
-                case 142 /* MethodSignature */:
-                case 145 /* GetAccessor */:
-                case 146 /* SetAccessor */:
-                case 147 /* CallSignature */:
-                case 148 /* ConstructSignature */:
-                case 149 /* IndexSignature */:
-                case 152 /* FunctionType */:
-                case 153 /* ConstructorType */:
-                    return true;
-            }
-        }
-        return false;
+        return node && isFunctionLikeKind(node.kind);
     }
     ts.isFunctionLike = isFunctionLike;
+    function isFunctionLikeKind(kind) {
+        switch (kind) {
+            case 144 /* Constructor */:
+            case 173 /* FunctionExpression */:
+            case 213 /* FunctionDeclaration */:
+            case 174 /* ArrowFunction */:
+            case 143 /* MethodDeclaration */:
+            case 142 /* MethodSignature */:
+            case 145 /* GetAccessor */:
+            case 146 /* SetAccessor */:
+            case 147 /* CallSignature */:
+            case 148 /* ConstructSignature */:
+            case 149 /* IndexSignature */:
+            case 152 /* FunctionType */:
+            case 153 /* ConstructorType */:
+                return true;
+        }
+    }
+    ts.isFunctionLikeKind = isFunctionLikeKind;
     function introducesArgumentsExoticObject(node) {
         switch (node.kind) {
             case 143 /* MethodDeclaration */:
@@ -6206,9 +6579,18 @@ var ts;
         return !!node && (node.kind === 162 /* ArrayBindingPattern */ || node.kind === 161 /* ObjectBindingPattern */);
     }
     ts.isBindingPattern = isBindingPattern;
+    function isNodeDescendentOf(node, ancestor) {
+        while (node) {
+            if (node === ancestor)
+                return true;
+            node = node.parent;
+        }
+        return false;
+    }
+    ts.isNodeDescendentOf = isNodeDescendentOf;
     function isInAmbientContext(node) {
         while (node) {
-            if (node.flags & (2 /* Ambient */ | 8192 /* DeclarationFile */)) {
+            if (node.flags & (4 /* Ambient */ | 4096 /* DeclarationFile */)) {
                 return true;
             }
             node = node.parent;
@@ -6266,7 +6648,7 @@ var ts;
             case 207 /* LabeledStatement */:
             case 204 /* ReturnStatement */:
             case 206 /* SwitchStatement */:
-            case 98 /* ThrowKeyword */:
+            case 208 /* ThrowStatement */:
             case 209 /* TryStatement */:
             case 193 /* VariableStatement */:
             case 198 /* WhileStatement */:
@@ -6379,8 +6761,8 @@ var ts;
     ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes;
     function getHeritageClause(clauses, kind) {
         if (clauses) {
-            for (var _i = 0; _i < clauses.length; _i++) {
-                var clause = clauses[_i];
+            for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) {
+                var clause = clauses_1[_i];
                 if (clause.token === kind) {
                     return clause;
                 }
@@ -6392,7 +6774,6 @@ var ts;
     function tryResolveScriptReference(host, sourceFile, reference) {
         if (!host.getCompilerOptions().noResolve) {
             var referenceFileName = ts.isRootedDiskPath(reference.fileName) ? reference.fileName : ts.combinePaths(ts.getDirectoryPath(sourceFile.fileName), reference.fileName);
-            referenceFileName = ts.getNormalizedAbsolutePath(referenceFileName, host.getCurrentDirectory());
             return host.getSourceFile(referenceFileName);
         }
     }
@@ -6450,7 +6831,7 @@ var ts;
     }
     ts.isTrivia = isTrivia;
     function isAsyncFunctionLike(node) {
-        return isFunctionLike(node) && (node.flags & 512 /* Async */) !== 0 && !isAccessor(node);
+        return isFunctionLike(node) && (node.flags & 256 /* Async */) !== 0 && !isAccessor(node);
     }
     ts.isAsyncFunctionLike = isAsyncFunctionLike;
     /**
@@ -6837,7 +7218,7 @@ var ts;
         else {
             ts.forEach(declarations, function (member) {
                 if ((member.kind === 145 /* GetAccessor */ || member.kind === 146 /* SetAccessor */)
-                    && (member.flags & 128 /* Static */) === (accessor.flags & 128 /* Static */)) {
+                    && (member.flags & 64 /* Static */) === (accessor.flags & 64 /* Static */)) {
                     var memberName = getPropertyNameForPropertyNameNode(member.name);
                     var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
                     if (memberName === accessorName) {
@@ -6894,6 +7275,66 @@ var ts;
         });
     }
     ts.emitComments = emitComments;
+    /**
+     * Detached comment is a comment at the top of file or function body that is separated from
+     * the next statement by space.
+     */
+    function emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, removeComments) {
+        var leadingComments;
+        var currentDetachedCommentInfo;
+        if (removeComments) {
+            // removeComments is true, only reserve pinned comment at the top of file
+            // For example:
+            //      /*! Pinned Comment */
+            //
+            //      var x = 10;
+            if (node.pos === 0) {
+                leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComment);
+            }
+        }
+        else {
+            // removeComments is false, just get detached as normal and bypass the process to filter comment
+            leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
+        }
+        if (leadingComments) {
+            var detachedComments = [];
+            var lastComment;
+            for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) {
+                var comment = leadingComments_1[_i];
+                if (lastComment) {
+                    var lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end);
+                    var commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos);
+                    if (commentLine >= lastCommentLine + 2) {
+                        // There was a blank line between the last comment and this comment.  This
+                        // comment is not part of the copyright comments.  Return what we have so
+                        // far.
+                        break;
+                    }
+                }
+                detachedComments.push(comment);
+                lastComment = comment;
+            }
+            if (detachedComments.length) {
+                // All comments look like they could have been part of the copyright header.  Make
+                // sure there is at least one blank line between it and the node.  If not, it's not
+                // a copyright header.
+                var lastCommentLine = getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
+                var nodeLine = getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
+                if (nodeLine >= lastCommentLine + 2) {
+                    // Valid detachedComments
+                    emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
+                    emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
+                    currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
+                }
+            }
+        }
+        return currentDetachedCommentInfo;
+        function isPinnedComment(comment) {
+            return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
+                currentSourceFile.text.charCodeAt(comment.pos + 2) === 33 /* exclamation */;
+        }
+    }
+    ts.emitDetachedComments = emitDetachedComments;
     function writeCommentRange(currentSourceFile, writer, comment, newLine) {
         if (currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */) {
             var firstCommentLineAndCharacter = ts.getLineAndCharacterOfPosition(currentSourceFile, comment.pos);
@@ -6983,16 +7424,16 @@ var ts;
     ts.writeCommentRange = writeCommentRange;
     function modifierToFlag(token) {
         switch (token) {
-            case 113 /* StaticKeyword */: return 128 /* Static */;
-            case 112 /* PublicKeyword */: return 16 /* Public */;
-            case 111 /* ProtectedKeyword */: return 64 /* Protected */;
-            case 110 /* PrivateKeyword */: return 32 /* Private */;
-            case 115 /* AbstractKeyword */: return 256 /* Abstract */;
-            case 82 /* ExportKeyword */: return 1 /* Export */;
-            case 122 /* DeclareKeyword */: return 2 /* Ambient */;
-            case 74 /* ConstKeyword */: return 32768 /* Const */;
-            case 77 /* DefaultKeyword */: return 1024 /* Default */;
-            case 118 /* AsyncKeyword */: return 512 /* Async */;
+            case 113 /* StaticKeyword */: return 64 /* Static */;
+            case 112 /* PublicKeyword */: return 8 /* Public */;
+            case 111 /* ProtectedKeyword */: return 32 /* Protected */;
+            case 110 /* PrivateKeyword */: return 16 /* Private */;
+            case 115 /* AbstractKeyword */: return 128 /* Abstract */;
+            case 82 /* ExportKeyword */: return 2 /* Export */;
+            case 122 /* DeclareKeyword */: return 4 /* Ambient */;
+            case 74 /* ConstKeyword */: return 16384 /* Const */;
+            case 77 /* DefaultKeyword */: return 512 /* Default */;
+            case 118 /* AsyncKeyword */: return 256 /* Async */;
         }
         return 0;
     }
@@ -7073,7 +7514,7 @@ var ts;
     }
     ts.isEmptyObjectLiteralOrArrayLiteral = isEmptyObjectLiteralOrArrayLiteral;
     function getLocalSymbolForExportDefault(symbol) {
-        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 1024 /* Default */) ? symbol.valueDeclaration.localSymbol : undefined;
+        return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & 512 /* Default */) ? symbol.valueDeclaration.localSymbol : undefined;
     }
     ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault;
     function isJavaScript(fileName) {
@@ -7150,6 +7591,12 @@ var ts;
         return result;
     }
     ts.convertToBase64 = convertToBase64;
+    function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
+        return !ts.isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : ts.getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, /* isAbsolutePathAnUrl */ false);
+    }
+    ts.convertToRelativePath = convertToRelativePath;
     var carriageReturnLineFeed = "\r\n";
     var lineFeed = "\n";
     function getNewLineCharacter(options) {
@@ -7414,8 +7861,8 @@ var ts;
     }
     function visitEachNode(cbNode, nodes) {
         if (nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
                 var result = cbNode(node);
                 if (result) {
                     return result;
@@ -7982,8 +8429,8 @@ var ts;
         function addJSDocComment(node) {
             var comments = ts.getLeadingCommentRangesOfNode(node, sourceFile);
             if (comments) {
-                for (var _i = 0; _i < comments.length; _i++) {
-                    var comment = comments[_i];
+                for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) {
+                    var comment = comments_1[_i];
                     var jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
                     if (jsDocComment) {
                         node.jsDocComment = jsDocComment;
@@ -8021,7 +8468,7 @@ var ts;
             sourceFile.bindDiagnostics = [];
             sourceFile.languageVersion = languageVersion;
             sourceFile.fileName = ts.normalizePath(fileName);
-            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 8192 /* DeclarationFile */ : 0;
+            sourceFile.flags = ts.fileExtensionIs(sourceFile.fileName, ".d.ts") ? 4096 /* DeclarationFile */ : 0;
             sourceFile.languageVariant = ts.isTsx(sourceFile.fileName) ? 1 /* JSX */ : 0 /* Standard */;
             return sourceFile;
         }
@@ -9079,7 +9526,7 @@ var ts;
             if (node.kind === 8 /* NumericLiteral */
                 && sourceText.charCodeAt(tokenPos) === 48 /* _0 */
                 && ts.isOctalDigit(sourceText.charCodeAt(tokenPos + 1))) {
-                node.flags |= 65536 /* OctalLiteral */;
+                node.flags |= 32768 /* OctalLiteral */;
             }
             return node;
         }
@@ -9832,7 +10279,7 @@ var ts;
                 // Didn't appear to actually be a parenthesized arrow function.  Just bail out.
                 return undefined;
             }
-            var isAsync = !!(arrowFunction.flags & 512 /* Async */);
+            var isAsync = !!(arrowFunction.flags & 256 /* Async */);
             // If we have an arrow, then try to parse the body. Even if not, try to parse if we
             // have an opening brace, just in case we're in an error state.
             var lastToken = token;
@@ -9959,7 +10406,7 @@ var ts;
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity) {
             var node = createNode(174 /* ArrowFunction */);
             setModifiers(node, parseModifiersForArrowFunction());
-            var isAsync = !!(node.flags & 512 /* Async */);
+            var isAsync = !!(node.flags & 256 /* Async */);
             // Arrow functions are never generators.
             //
             // If we're speculatively parsing a signature for a parenthesized arrow function, then
@@ -10802,7 +11249,7 @@ var ts;
             var node = createNode(164 /* ArrayLiteralExpression */);
             parseExpected(19 /* OpenBracketToken */);
             if (scanner.hasPrecedingLineBreak())
-                node.flags |= 2048 /* MultiLine */;
+                node.flags |= 1024 /* MultiLine */;
             node.elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
             parseExpected(20 /* CloseBracketToken */);
             return finishNode(node);
@@ -10863,7 +11310,7 @@ var ts;
             var node = createNode(165 /* ObjectLiteralExpression */);
             parseExpected(15 /* OpenBraceToken */);
             if (scanner.hasPrecedingLineBreak()) {
-                node.flags |= 2048 /* MultiLine */;
+                node.flags |= 1024 /* MultiLine */;
             }
             node.properties = parseDelimitedList(12 /* ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimeter*/ true);
             parseExpected(16 /* CloseBraceToken */);
@@ -10884,7 +11331,7 @@ var ts;
             parseExpected(87 /* FunctionKeyword */);
             node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512 /* Async */);
+            var isAsync = !!(node.flags & 256 /* Async */);
             node.name =
                 isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
                     isGenerator ? doInYieldContext(parseOptionalIdentifier) :
@@ -11476,10 +11923,10 @@ var ts;
                 case 102 /* VarKeyword */:
                     break;
                 case 108 /* LetKeyword */:
-                    node.flags |= 16384 /* Let */;
+                    node.flags |= 8192 /* Let */;
                     break;
                 case 74 /* ConstKeyword */:
-                    node.flags |= 32768 /* Const */;
+                    node.flags |= 16384 /* Const */;
                     break;
                 default:
                     ts.Debug.fail();
@@ -11522,9 +11969,9 @@ var ts;
             setModifiers(node, modifiers);
             parseExpected(87 /* FunctionKeyword */);
             node.asteriskToken = parseOptionalToken(37 /* AsteriskToken */);
-            node.name = node.flags & 1024 /* Default */ ? parseOptionalIdentifier() : parseIdentifier();
+            node.name = node.flags & 512 /* Default */ ? parseOptionalIdentifier() : parseIdentifier();
             var isGenerator = !!node.asteriskToken;
-            var isAsync = !!(node.flags & 512 /* Async */);
+            var isAsync = !!(node.flags & 256 /* Async */);
             fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
             node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, ts.Diagnostics.or_expected);
             return finishNode(node);
@@ -11546,7 +11993,7 @@ var ts;
             method.name = name;
             method.questionToken = questionToken;
             var isGenerator = !!asteriskToken;
-            var isAsync = !!(method.flags & 512 /* Async */);
+            var isAsync = !!(method.flags & 256 /* Async */);
             fillSignature(54 /* ColonToken */, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method);
             method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
             return finishNode(method);
@@ -11567,7 +12014,7 @@ var ts;
             //        AccessibilityModifier_opt  static_opt  PropertyName   TypeAnnotation_opt   Initialiser_opt[In, ?Yield];
             //
             // The checker may still error in the static case to explicitly disallow the yield expression.
-            property.initializer = modifiers && modifiers.flags & 128 /* Static */
+            property.initializer = modifiers && modifiers.flags & 64 /* Static */
                 ? allowInAnd(parseNonParameterInitializer)
                 : doOutsideOfContext(2 /* Yield */ | 1 /* DisallowIn */, parseNonParameterInitializer);
             parseSemicolon();
@@ -11900,13 +12347,13 @@ var ts;
             var node = createNode(218 /* ModuleDeclaration */, fullStart);
             // If we are parsing a dotted namespace name, we want to
             // propagate the 'Namespace' flag across the names if set.
-            var namespaceFlag = flags & 131072 /* Namespace */;
+            var namespaceFlag = flags & 65536 /* Namespace */;
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.flags |= flags;
             node.name = parseIdentifier();
             node.body = parseOptional(21 /* DotToken */)
-                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, 1 /* Export */ | namespaceFlag)
+                ? parseModuleOrNamespaceDeclaration(getNodePos(), /*decorators*/ undefined, /*modifiers*/ undefined, 2 /* Export */ | namespaceFlag)
                 : parseModuleBlock();
             return finishNode(node);
         }
@@ -11921,7 +12368,7 @@ var ts;
         function parseModuleDeclaration(fullStart, decorators, modifiers) {
             var flags = modifiers ? modifiers.flags : 0;
             if (parseOptional(126 /* NamespaceKeyword */)) {
-                flags |= 131072 /* Namespace */;
+                flags |= 65536 /* Namespace */;
             }
             else {
                 parseExpected(125 /* ModuleKeyword */);
@@ -12179,7 +12626,7 @@ var ts;
         }
         function setExternalModuleIndicator(sourceFile) {
             sourceFile.externalModuleIndicator = ts.forEach(sourceFile.statements, function (node) {
-                return node.flags & 1 /* Export */
+                return node.flags & 2 /* Export */
                     || node.kind === 221 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 232 /* ExternalModuleReference */
                     || node.kind === 222 /* ImportDeclaration */
                     || node.kind === 227 /* ExportAssignment */
@@ -12868,8 +13315,8 @@ var ts;
                 array._children = undefined;
                 array.pos += delta;
                 array.end += delta;
-                for (var _i = 0; _i < array.length; _i++) {
-                    var node = array[_i];
+                for (var _i = 0, array_7 = array; _i < array_7.length; _i++) {
+                    var node = array_7[_i];
                     visitNode(node);
                 }
             }
@@ -13006,8 +13453,8 @@ var ts;
                     array._children = undefined;
                     // Adjust the pos or end (or both) of the intersecting array accordingly.
                     adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
-                    for (var _i = 0; _i < array.length; _i++) {
-                        var node = array[_i];
+                    for (var _i = 0, array_8 = array; _i < array_8.length; _i++) {
+                        var node = array_8[_i];
                         visitNode(node);
                     }
                     return;
@@ -13374,6 +13821,7 @@ var ts;
         var getInstantiatedGlobalPromiseLikeType;
         var getGlobalPromiseConstructorLikeType;
         var getGlobalThenableType;
+        var jsxElementClassType;
         var tupleTypes = {};
         var unionTypes = {};
         var intersectionTypes = {};
@@ -13643,7 +14091,7 @@ var ts;
                     }
                     var initializerOfNonStaticProperty = current.parent &&
                         current.parent.kind === 141 /* PropertyDeclaration */ &&
-                        (current.parent.flags & 128 /* Static */) === 0 &&
+                        (current.parent.flags & 64 /* Static */) === 0 &&
                         current.parent.initializer === current;
                     if (initializerOfNonStaticProperty) {
                         return true;
@@ -13725,7 +14173,7 @@ var ts;
                         // local variables of the constructor. This effectively means that entities from outer scopes
                         // by the same name as a constructor parameter or local variable are inaccessible
                         // in initializer expressions for instance member variables.
-                        if (ts.isClassLike(location.parent) && !(location.flags & 128 /* Static */)) {
+                        if (ts.isClassLike(location.parent) && !(location.flags & 64 /* Static */)) {
                             var ctor = findConstructorDeclaration(location.parent);
                             if (ctor && ctor.locals) {
                                 if (getSymbol(ctor.locals, name, meaning & 107455 /* Value */)) {
@@ -13739,7 +14187,7 @@ var ts;
                     case 186 /* ClassExpression */:
                     case 215 /* InterfaceDeclaration */:
                         if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & 793056 /* Type */)) {
-                            if (lastLocation && lastLocation.flags & 128 /* Static */) {
+                            if (lastLocation && lastLocation.flags & 64 /* Static */) {
                                 // TypeScript 1.0 spec (April 2014): 3.4.1
                                 // The scope of a type parameter extends over the entire declaration with which the type
                                 // parameter list is associated, with the exception of static member declarations in classes.
@@ -14267,8 +14715,8 @@ var ts;
         }
         function findConstructorDeclaration(node) {
             var members = node.members;
-            for (var _i = 0; _i < members.length; _i++) {
-                var member = members[_i];
+            for (var _i = 0, members_1 = members; _i < members_1.length; _i++) {
+                var member = members_1[_i];
                 if (member.kind === 144 /* Constructor */ && ts.nodeIsPresent(member.body)) {
                     return member;
                 }
@@ -14515,7 +14963,7 @@ var ts;
                     // because these kind of aliases can be used to name types in declaration file
                     var anyImportSyntax = getAnyImportSyntax(declaration);
                     if (anyImportSyntax &&
-                        !(anyImportSyntax.flags & 1 /* Export */) &&
+                        !(anyImportSyntax.flags & 2 /* Export */) &&
                         isDeclarationVisible(anyImportSyntax.parent)) {
                         getNodeLinks(declaration).isVisible = true;
                         if (aliasesToMakeVisible) {
@@ -14669,8 +15117,8 @@ var ts;
                             walkSymbol(getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol), getQualifiedLeftMeaning(meaning));
                         }
                         if (accessibleSymbolChain) {
-                            for (var _i = 0; _i < accessibleSymbolChain.length; _i++) {
-                                var accessibleSymbol = accessibleSymbolChain[_i];
+                            for (var _i = 0, accessibleSymbolChain_1 = accessibleSymbolChain; _i < accessibleSymbolChain_1.length; _i++) {
+                                var accessibleSymbol = accessibleSymbolChain_1[_i];
                                 appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
                             }
                         }
@@ -14860,7 +15308,7 @@ var ts;
                     }
                     function shouldWriteTypeOfFunctionSymbol() {
                         var isStaticMethodSymbol = !!(symbol.flags & 8192 /* Method */ &&
-                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 128 /* Static */; }));
+                            ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 64 /* Static */; }));
                         var isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) &&
                             (symbol.parent ||
                                 ts.forEach(symbol.declarations, function (declaration) {
@@ -14971,8 +15419,8 @@ var ts;
                         var t = getTypeOfSymbol(p);
                         if (p.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(t).length) {
                             var signatures = getSignaturesOfType(t, 0 /* Call */);
-                            for (var _f = 0; _f < signatures.length; _f++) {
-                                var signature = signatures[_f];
+                            for (var _f = 0, signatures_1 = signatures; _f < signatures_1.length; _f++) {
+                                var signature = signatures_1[_f];
                                 buildSymbolDisplay(p, writer);
                                 if (p.flags & 536870912 /* Optional */) {
                                     writePunctuation(writer, 53 /* QuestionToken */);
@@ -15186,7 +15634,7 @@ var ts;
                     case 221 /* ImportEqualsDeclaration */:
                         var parent_4 = getDeclarationContainer(node);
                         // If the node is not exported or it is not ambient module element (except import declaration)
-                        if (!(ts.getCombinedNodeFlags(node) & 1 /* Export */) &&
+                        if (!(ts.getCombinedNodeFlags(node) & 2 /* Export */) &&
                             !(node.kind !== 221 /* ImportEqualsDeclaration */ && parent_4.kind !== 248 /* SourceFile */ && ts.isInAmbientContext(parent_4))) {
                             return isGlobalSourceFile(parent_4);
                         }
@@ -15198,7 +15646,7 @@ var ts;
                     case 146 /* SetAccessor */:
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
-                        if (node.flags & (32 /* Private */ | 64 /* Protected */)) {
+                        if (node.flags & (16 /* Private */ | 32 /* Protected */)) {
                             // Private/protected properties/methods are not visible
                             return false;
                         }
@@ -15728,8 +16176,8 @@ var ts;
         // The function allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set
         // in-place and returns the same array.
         function appendTypeParameters(typeParameters, declarations) {
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
+                var declaration = declarations_2[_i];
                 var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
                 if (!typeParameters) {
                     typeParameters = [tp];
@@ -15934,13 +16382,13 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var declaration = _a[_i];
                 if (declaration.kind === 215 /* InterfaceDeclaration */) {
-                    if (declaration.flags & 524288 /* ContainsThis */) {
+                    if (declaration.flags & 262144 /* ContainsThis */) {
                         return false;
                     }
                     var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration);
                     if (baseTypeNodes) {
-                        for (var _b = 0; _b < baseTypeNodes.length; _b++) {
-                            var node = baseTypeNodes[_b];
+                        for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) {
+                            var node = baseTypeNodes_1[_b];
                             if (ts.isSupportedExpressionWithTypeArguments(node)) {
                                 var baseSymbol = resolveEntityName(node.expression, 793056 /* Type */, /*ignoreErrors*/ true);
                                 if (!baseSymbol || !(baseSymbol.flags & 64 /* Interface */) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
@@ -16130,8 +16578,8 @@ var ts;
         }
         function createSymbolTable(symbols) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+                var symbol = symbols_1[_i];
                 result[symbol.name] = symbol;
             }
             return result;
@@ -16140,15 +16588,15 @@ var ts;
         // we check symbols to see if we can quickly conclude they are free of "this" references, thus needing no instantiation.
         function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
             var result = {};
-            for (var _i = 0; _i < symbols.length; _i++) {
-                var symbol = symbols[_i];
+            for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+                var symbol = symbols_2[_i];
                 result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
             }
             return result;
         }
         function addInheritedMembers(symbols, baseSymbols) {
-            for (var _i = 0; _i < baseSymbols.length; _i++) {
-                var s = baseSymbols[_i];
+            for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) {
+                var s = baseSymbols_1[_i];
                 if (!ts.hasProperty(symbols, s.name)) {
                     symbols[s.name] = s;
                 }
@@ -16156,8 +16604,8 @@ var ts;
         }
         function addInheritedSignatures(signatures, baseSignatures) {
             if (baseSignatures) {
-                for (var _i = 0; _i < baseSignatures.length; _i++) {
-                    var signature = baseSignatures[_i];
+                for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) {
+                    var signature = baseSignatures_1[_i];
                     signatures.push(signature);
                 }
             }
@@ -16200,8 +16648,8 @@ var ts;
                     members = createSymbolTable(source.declaredProperties);
                 }
                 var thisArgument = ts.lastOrUndefined(typeArguments);
-                for (var _i = 0; _i < baseTypes.length; _i++) {
-                    var baseType = baseTypes[_i];
+                for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) {
+                    var baseType = baseTypes_1[_i];
                     var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
                     addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
                     callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */));
@@ -16247,8 +16695,8 @@ var ts;
             var typeArguments = ts.map(baseTypeNode.typeArguments, getTypeFromTypeNode);
             var typeArgCount = typeArguments ? typeArguments.length : 0;
             var result = [];
-            for (var _i = 0; _i < baseSignatures.length; _i++) {
-                var baseSig = baseSignatures[_i];
+            for (var _i = 0, baseSignatures_2 = baseSignatures; _i < baseSignatures_2.length; _i++) {
+                var baseSig = baseSignatures_2[_i];
                 var typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
                 if (typeParamCount === typeArgCount) {
                     var sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
@@ -16277,8 +16725,8 @@ var ts;
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
         }
         function findMatchingSignature(signatureList, signature, partialMatch, ignoreReturnTypes) {
-            for (var _i = 0; _i < signatureList.length; _i++) {
-                var s = signatureList[_i];
+            for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) {
+                var s = signatureList_1[_i];
                 if (compareSignatures(s, signature, partialMatch, ignoreReturnTypes, compareTypes)) {
                     return s;
                 }
@@ -16342,8 +16790,8 @@ var ts;
         }
         function getUnionIndexType(types, kind) {
             var indexTypes = [];
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+                var type = types_1[_i];
                 var indexType = getIndexTypeOfType(type, kind);
                 if (!indexType) {
                     return undefined;
@@ -16522,12 +16970,12 @@ var ts;
         function createUnionOrIntersectionProperty(containingType, name) {
             var types = containingType.types;
             var props;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_2 = types; _i < types_2.length; _i++) {
+                var current = types_2[_i];
                 var type = getApparentType(current);
                 if (type !== unknownType) {
                     var prop = getPropertyOfType(type, name);
-                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (32 /* Private */ | 64 /* Protected */))) {
+                    if (prop && !(getDeclarationFlagsFromSymbol(prop) & (16 /* Private */ | 32 /* Protected */))) {
                         if (!props) {
                             props = [prop];
                         }
@@ -16549,8 +16997,8 @@ var ts;
             }
             var propTypes = [];
             var declarations = [];
-            for (var _a = 0; _a < props.length; _a++) {
-                var prop = props[_a];
+            for (var _a = 0, props_1 = props; _a < props_1.length; _a++) {
+                var prop = props_1[_a];
                 if (prop.declarations) {
                     ts.addRange(declarations, prop.declarations);
                 }
@@ -16908,8 +17356,8 @@ var ts;
         // that care about the presence of such types at arbitrary depth in a containing type.
         function getPropagatingFlagsOfTypes(types) {
             var result = 0;
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_3 = types; _i < types_3.length; _i++) {
+                var type = types_3[_i];
                 result |= type.flags;
             }
             return result & 14680064 /* PropagatingFlags */;
@@ -17059,8 +17507,8 @@ var ts;
         function getTypeOfGlobalSymbol(symbol, arity) {
             function getTypeDeclaration(symbol) {
                 var declarations = symbol.declarations;
-                for (var _i = 0; _i < declarations.length; _i++) {
-                    var declaration = declarations[_i];
+                for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) {
+                    var declaration = declarations_3[_i];
                     switch (declaration.kind) {
                         case 214 /* ClassDeclaration */:
                         case 215 /* InterfaceDeclaration */:
@@ -17170,8 +17618,8 @@ var ts;
         // Add the given types to the given type set. Order is preserved, duplicates are removed,
         // and nested types of the given kind are flattened into the set.
         function addTypesToSet(typeSet, types, typeSetKind) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_4 = types; _i < types_4.length; _i++) {
+                var type = types_4[_i];
                 addTypeToSet(typeSet, type, typeSetKind);
             }
         }
@@ -17193,8 +17641,8 @@ var ts;
             }
         }
         function containsTypeAny(types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_5 = types; _i < types_5.length; _i++) {
+                var type = types_5[_i];
                 if (isTypeAny(type)) {
                     return true;
                 }
@@ -17310,7 +17758,8 @@ var ts;
             var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false);
             var parent = container && container.parent;
             if (parent && (ts.isClassLike(parent) || parent.kind === 215 /* InterfaceDeclaration */)) {
-                if (!(container.flags & 128 /* Static */)) {
+                if (!(container.flags & 64 /* Static */) &&
+                    (container.kind !== 144 /* Constructor */ || ts.isNodeDescendentOf(node, container.body))) {
                     return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
                 }
             }
@@ -17377,8 +17826,8 @@ var ts;
         function instantiateList(items, mapper, instantiator) {
             if (items && items.length) {
                 var result = [];
-                for (var _i = 0; _i < items.length; _i++) {
-                    var v = items[_i];
+                for (var _i = 0, items_1 = items; _i < items_1.length; _i++) {
+                    var v = items_1[_i];
                     result.push(instantiator(v, mapper));
                 }
                 return result;
@@ -17417,8 +17866,8 @@ var ts;
                 case 2: return createBinaryTypeEraser(sources[0], sources[1]);
             }
             return function (t) {
-                for (var _i = 0; _i < sources.length; _i++) {
-                    var source = sources[_i];
+                for (var _i = 0, sources_1 = sources; _i < sources_1.length; _i++) {
+                    var source = sources_1[_i];
                     if (t === source) {
                         return anyType;
                     }
@@ -17836,8 +18285,8 @@ var ts;
             function eachTypeRelatedToSomeType(source, target) {
                 var result = -1 /* True */;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) {
+                    var sourceType = sourceTypes_1[_i];
                     var related = typeRelatedToSomeType(sourceType, target, false);
                     if (!related) {
                         return 0 /* False */;
@@ -17859,8 +18308,8 @@ var ts;
             function typeRelatedToEachType(source, target, reportErrors) {
                 var result = -1 /* True */;
                 var targetTypes = target.types;
-                for (var _i = 0; _i < targetTypes.length; _i++) {
-                    var targetType = targetTypes[_i];
+                for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) {
+                    var targetType = targetTypes_1[_i];
                     var related = isRelatedTo(source, targetType, reportErrors);
                     if (!related) {
                         return 0 /* False */;
@@ -17882,8 +18331,8 @@ var ts;
             function eachTypeRelatedToType(source, target, reportErrors) {
                 var result = -1 /* True */;
                 var sourceTypes = source.types;
-                for (var _i = 0; _i < sourceTypes.length; _i++) {
-                    var sourceType = sourceTypes[_i];
+                for (var _i = 0, sourceTypes_2 = sourceTypes; _i < sourceTypes_2.length; _i++) {
+                    var sourceType = sourceTypes_2[_i];
                     var related = isRelatedTo(sourceType, target, reportErrors);
                     if (!related) {
                         return 0 /* False */;
@@ -18008,8 +18457,8 @@ var ts;
                 var result = -1 /* True */;
                 var properties = getPropertiesOfObjectType(target);
                 var requireOptionalProperties = relation === subtypeRelation && !(source.flags & 524288 /* ObjectLiteral */);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {
+                    var targetProp = properties_1[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
@@ -18023,20 +18472,20 @@ var ts;
                         else if (!(targetProp.flags & 134217728 /* Prototype */)) {
                             var sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
                             var targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
-                            if (sourcePropFlags & 32 /* Private */ || targetPropFlags & 32 /* Private */) {
+                            if (sourcePropFlags & 16 /* Private */ || targetPropFlags & 16 /* Private */) {
                                 if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
                                     if (reportErrors) {
-                                        if (sourcePropFlags & 32 /* Private */ && targetPropFlags & 32 /* Private */) {
+                                        if (sourcePropFlags & 16 /* Private */ && targetPropFlags & 16 /* Private */) {
                                             reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
                                         }
                                         else {
-                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 32 /* Private */ ? source : target), typeToString(sourcePropFlags & 32 /* Private */ ? target : source));
+                                            reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 16 /* Private */ ? source : target), typeToString(sourcePropFlags & 16 /* Private */ ? target : source));
                                         }
                                     }
                                     return 0 /* False */;
                                 }
                             }
-                            else if (targetPropFlags & 64 /* Protected */) {
+                            else if (targetPropFlags & 32 /* Protected */) {
                                 var sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & 32 /* Class */;
                                 var sourceClass = sourceDeclaredInClass ? getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
                                 var targetClass = getDeclaredTypeOfSymbol(targetProp.parent);
@@ -18047,7 +18496,7 @@ var ts;
                                     return 0 /* False */;
                                 }
                             }
-                            else if (sourcePropFlags & 64 /* Protected */) {
+                            else if (sourcePropFlags & 32 /* Protected */) {
                                 if (reportErrors) {
                                     reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target));
                                 }
@@ -18089,8 +18538,8 @@ var ts;
                     return 0 /* False */;
                 }
                 var result = -1 /* True */;
-                for (var _i = 0; _i < sourceProperties.length; _i++) {
-                    var sourceProp = sourceProperties[_i];
+                for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) {
+                    var sourceProp = sourceProperties_1[_i];
                     var targetProp = getPropertyOfObjectType(target, sourceProp.name);
                     if (!targetProp) {
                         return 0 /* False */;
@@ -18130,13 +18579,13 @@ var ts;
                         return result;
                     }
                 }
-                outer: for (var _i = 0; _i < targetSignatures.length; _i++) {
-                    var t = targetSignatures[_i];
+                outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
+                    var t = targetSignatures_1[_i];
                     if (!t.hasStringLiterals || target.flags & 262144 /* FromSignature */) {
                         var localErrors = reportErrors;
                         var checkedAbstractAssignability = false;
-                        for (var _a = 0; _a < sourceSignatures.length; _a++) {
-                            var s = sourceSignatures[_a];
+                        for (var _a = 0, sourceSignatures_1 = sourceSignatures; _a < sourceSignatures_1.length; _a++) {
+                            var s = sourceSignatures_1[_a];
                             if (!s.hasStringLiterals || source.flags & 262144 /* FromSignature */) {
                                 var related = signatureRelatedTo(s, t, localErrors);
                                 if (related) {
@@ -18167,8 +18616,8 @@ var ts;
                         var targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
                         var sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
                         var targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
-                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 256 /* Abstract */;
-                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 256 /* Abstract */;
+                        var sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & 128 /* Abstract */;
+                        var targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & 128 /* Abstract */;
                         if (sourceIsAbstract && !(targetIsAbstract && targetDecl)) {
                             // if target isn't a class-declaration type, then it can be new'd, so we forbid the assignment.
                             if (reportErrors) {
@@ -18284,7 +18733,7 @@ var ts;
                 var targetType = getIndexTypeOfType(target, 0 /* String */);
                 if (targetType) {
                     if ((targetType.flags & 1 /* Any */) && !(originalSource.flags & 16777726 /* Primitive */)) {
-                        // non-primitive assignment to any is always allowed, eg 
+                        // non-primitive assignment to any is always allowed, eg
                         //   `var x: { [index: string]: any } = { property: 12 };`
                         return -1 /* True */;
                     }
@@ -18313,7 +18762,7 @@ var ts;
                 var targetType = getIndexTypeOfType(target, 1 /* Number */);
                 if (targetType) {
                     if ((targetType.flags & 1 /* Any */) && !(originalSource.flags & 16777726 /* Primitive */)) {
-                        // non-primitive assignment to any is always allowed, eg 
+                        // non-primitive assignment to any is always allowed, eg
                         //   `var x: { [index: number]: any } = { property: 12 };`
                         return -1 /* True */;
                     }
@@ -18386,8 +18835,8 @@ var ts;
             if (sourceProp === targetProp) {
                 return -1 /* True */;
             }
-            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (32 /* Private */ | 64 /* Protected */);
-            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (32 /* Private */ | 64 /* Protected */);
+            var sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (16 /* Private */ | 32 /* Protected */);
+            var targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (16 /* Private */ | 32 /* Protected */);
             if (sourcePropAccessibility !== targetPropAccessibility) {
                 return 0 /* False */;
             }
@@ -18455,8 +18904,8 @@ var ts;
             return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1;
         }
         function isSupertypeOfEach(candidate, types) {
-            for (var _i = 0; _i < types.length; _i++) {
-                var type = types[_i];
+            for (var _i = 0, types_6 = types; _i < types_6.length; _i++) {
+                var type = types_6[_i];
                 if (candidate !== type && !isTypeSubtypeOf(type, candidate))
                     return false;
             }
@@ -18692,8 +19141,8 @@ var ts;
         }
         function createInferenceContext(typeParameters, inferUnionTypes) {
             var inferences = [];
-            for (var _i = 0; _i < typeParameters.length; _i++) {
-                var unused = typeParameters[_i];
+            for (var _i = 0, typeParameters_1 = typeParameters; _i < typeParameters_1.length; _i++) {
+                var unused = typeParameters_1[_i];
                 inferences.push({
                     primary: undefined, secondary: undefined, isFixed: false
                 });
@@ -18774,8 +19223,8 @@ var ts;
                     var typeParameterCount = 0;
                     var typeParameter;
                     // First infer to each type in union or intersection that isn't a type parameter
-                    for (var _i = 0; _i < targetTypes.length; _i++) {
-                        var t = targetTypes[_i];
+                    for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) {
+                        var t = targetTypes_2[_i];
                         if (t.flags & 512 /* TypeParameter */ && ts.contains(context.typeParameters, t)) {
                             typeParameter = t;
                             typeParameterCount++;
@@ -18797,8 +19246,8 @@ var ts;
                 else if (source.flags & 49152 /* UnionOrIntersection */) {
                     // Source is a union or intersection type, infer from each consituent type
                     var sourceTypes = source.types;
-                    for (var _a = 0; _a < sourceTypes.length; _a++) {
-                        var sourceType = sourceTypes[_a];
+                    for (var _a = 0, sourceTypes_3 = sourceTypes; _a < sourceTypes_3.length; _a++) {
+                        var sourceType = sourceTypes_3[_a];
                         inferFromTypes(sourceType, target);
                     }
                 }
@@ -18832,8 +19281,8 @@ var ts;
             }
             function inferFromProperties(source, target) {
                 var properties = getPropertiesOfObjectType(target);
-                for (var _i = 0; _i < properties.length; _i++) {
-                    var targetProp = properties[_i];
+                for (var _i = 0, properties_2 = properties; _i < properties_2.length; _i++) {
+                    var targetProp = properties_2[_i];
                     var sourceProp = getPropertyOfObjectType(source, targetProp.name);
                     if (sourceProp) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
@@ -19324,9 +19773,9 @@ var ts;
                 symbol.valueDeclaration.parent.kind === 244 /* CatchClause */) {
                 return;
             }
-            // 1. walk from the use site up to the declaration and check 
+            // 1. walk from the use site up to the declaration and check
             // if there is anything function like between declaration and use-site (is binding/class is captured in function).
-            // 2. walk from the declaration up to the boundary of lexical environment and check 
+            // 2. walk from the declaration up to the boundary of lexical environment and check
             // if there is an iteration statement in between declaration and boundary (is binding/class declared inside iteration statement)
             var container;
             if (symbol.flags & 32 /* Class */) {
@@ -19398,7 +19847,7 @@ var ts;
                     break;
                 case 141 /* PropertyDeclaration */:
                 case 140 /* PropertySignature */:
-                    if (container.flags & 128 /* Static */) {
+                    if (container.flags & 64 /* Static */) {
                         error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_static_property_initializer);
                     }
                     break;
@@ -19411,7 +19860,7 @@ var ts;
             }
             if (ts.isClassLike(container.parent)) {
                 var symbol = getSymbolOfNode(container.parent);
-                return container.flags & 128 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
+                return container.flags & 64 /* Static */ ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
             }
             return anyType;
         }
@@ -19441,7 +19890,7 @@ var ts;
             var nodeCheckFlag = 0;
             // always set NodeCheckFlags for 'super' expression node
             if (canUseSuperExpression) {
-                if ((container.flags & 128 /* Static */) || isCallExpression) {
+                if ((container.flags & 64 /* Static */) || isCallExpression) {
                     nodeCheckFlag = 512 /* SuperStatic */;
                 }
                 else {
@@ -19497,7 +19946,7 @@ var ts;
                     // - In a static member function or static member accessor
                     // topmost container must be something that is directly nested in the class declaration
                     if (container && ts.isClassLike(container.parent)) {
-                        if (container.flags & 128 /* Static */) {
+                        if (container.flags & 64 /* Static */) {
                             return container.kind === 143 /* MethodDeclaration */ ||
                                 container.kind === 142 /* MethodSignature */ ||
                                 container.kind === 145 /* GetAccessor */ ||
@@ -19654,8 +20103,8 @@ var ts;
             var types = type.types;
             var mappedType;
             var mappedTypes;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_7 = types; _i < types_7.length; _i++) {
+                var current = types_7[_i];
                 var t = mapper(current);
                 if (t) {
                     if (!mappedType) {
@@ -19845,8 +20294,8 @@ var ts;
             }
             var signatureList;
             var types = type.types;
-            for (var _i = 0; _i < types.length; _i++) {
-                var current = types[_i];
+            for (var _i = 0, types_8 = types; _i < types_8.length; _i++) {
+                var current = types_8[_i];
                 var signature = getNonGenericSignature(current);
                 if (signature) {
                     if (!signatureList) {
@@ -19926,8 +20375,8 @@ var ts;
             var hasSpreadElement = false;
             var elementTypes = [];
             var inDestructuringPattern = isAssignmentTarget(node);
-            for (var _i = 0; _i < elements.length; _i++) {
-                var e = elements[_i];
+            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+                var e = elements_1[_i];
                 if (inDestructuringPattern && e.kind === 185 /* SpreadElementExpression */) {
                     // Given the following situation:
                     //    var c: {};
@@ -20259,8 +20708,8 @@ var ts;
         function checkJsxSpreadAttribute(node, elementAttributesType, nameTable) {
             var type = checkExpression(node.expression);
             var props = getPropertiesOfType(type);
-            for (var _i = 0; _i < props.length; _i++) {
-                var prop = props[_i];
+            for (var _i = 0, props_2 = props; _i < props_2.length; _i++) {
+                var prop = props_2[_i];
                 // Is there a corresponding property in the element attributes type? Skip checking of properties
                 // that have already been assigned to, as these are not actually pushed into the resulting type
                 if (!nameTable[prop.name]) {
@@ -20479,7 +20928,6 @@ var ts;
             var prop = getPropertyOfType(attributesType, attrib.name.text);
             return prop || unknownSymbol;
         }
-        var jsxElementClassType = undefined;
         function getJsxGlobalElementClassType() {
             if (!jsxElementClassType) {
                 jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
@@ -20558,7 +21006,7 @@ var ts;
             return s.valueDeclaration ? s.valueDeclaration.kind : 141 /* PropertyDeclaration */;
         }
         function getDeclarationFlagsFromSymbol(s) {
-            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 16 /* Public */ | 128 /* Static */ : 0;
+            return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 8 /* Public */ | 64 /* Static */ : 0;
         }
         /**
          * Check whether the requested property access is valid.
@@ -20588,7 +21036,7 @@ var ts;
                     error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
                     return false;
                 }
-                if (flags & 256 /* Abstract */) {
+                if (flags & 128 /* Abstract */) {
                     // A method cannot be accessed in a super property access if the method is abstract.
                     // This error could mask a private property access error. But, a member
                     // cannot simultaneously be private and abstract, so this will trigger an
@@ -20598,7 +21046,7 @@ var ts;
                 }
             }
             // Public properties are otherwise accessible.
-            if (!(flags & (32 /* Private */ | 64 /* Protected */))) {
+            if (!(flags & (16 /* Private */ | 32 /* Protected */))) {
                 return true;
             }
             // Property is known to be private or protected at this point
@@ -20606,7 +21054,7 @@ var ts;
             var enclosingClassDeclaration = ts.getContainingClass(node);
             var enclosingClass = enclosingClassDeclaration ? getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
             // Private property is accessible if declaring and enclosing class are the same
-            if (flags & 32 /* Private */) {
+            if (flags & 16 /* Private */) {
                 if (declaringClass !== enclosingClass) {
                     error(node, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(declaringClass));
                     return false;
@@ -20624,7 +21072,7 @@ var ts;
                 return false;
             }
             // No further restrictions for static properties
-            if (flags & 128 /* Static */) {
+            if (flags & 64 /* Static */) {
                 return true;
             }
             // An instance property must be accessed through an instance of the enclosing class
@@ -20851,8 +21299,8 @@ var ts;
             var specializedIndex = -1;
             var spliceIndex;
             ts.Debug.assert(!result.length);
-            for (var _i = 0; _i < signatures.length; _i++) {
-                var signature = signatures[_i];
+            for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) {
+                var signature = signatures_2[_i];
                 var symbol = signature.declaration && getSymbolOfNode(signature.declaration);
                 var parent_5 = signature.declaration && signature.declaration.parent;
                 if (!lastSymbol || symbol === lastSymbol) {
@@ -21494,8 +21942,8 @@ var ts;
             //  declare function f(a: { xa: number; xb: number; });
             //  f({ |
             if (!produceDiagnostics) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var candidate = candidates[_i];
+                for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) {
+                    var candidate = candidates_1[_i];
                     if (hasCorrectArity(node, args, candidate)) {
                         if (candidate.typeParameters && typeArguments) {
                             candidate = getSignatureInstantiation(candidate, ts.map(typeArguments, getTypeFromTypeNode));
@@ -21514,8 +21962,8 @@ var ts;
                 diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(node, errorInfo));
             }
             function chooseOverload(candidates, relation) {
-                for (var _i = 0; _i < candidates.length; _i++) {
-                    var originalCandidate = candidates[_i];
+                for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
+                    var originalCandidate = candidates_2[_i];
                     if (!hasCorrectArity(node, args, originalCandidate)) {
                         continue;
                     }
@@ -21652,7 +22100,7 @@ var ts;
             // In the case of a merged class-module or class-interface declaration,
             // only the class declaration node will have the Abstract flag set.
             var valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
-            if (valueDecl && valueDecl.flags & 256 /* Abstract */) {
+            if (valueDecl && valueDecl.flags & 128 /* Abstract */) {
                 error(node, ts.Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, ts.declarationNameToString(valueDecl.name));
                 return resolveErrorCall(node);
             }
@@ -22017,19 +22465,11 @@ var ts;
             });
             return aggregatedTypes;
         }
-        function bodyContainsAReturnStatement(funcBody) {
-            return ts.forEachReturnStatement(funcBody, function (returnStatement) {
-                return true;
-            });
-        }
-        function bodyContainsSingleThrowStatement(body) {
-            return (body.statements.length === 1) && (body.statements[0].kind === 208 /* ThrowStatement */);
-        }
         // TypeScript Specification 1.0 (6.3) - July 2014
         // An explicitly typed function whose return type isn't the Void or the Any type
         // must have at least one return statement somewhere in its body.
         // An exception to this rule is if the function implementation consists of a single 'throw' statement.
-        function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func, returnType) {
+        function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
             if (!produceDiagnostics) {
                 return;
             }
@@ -22038,22 +22478,19 @@ var ts;
                 return;
             }
             // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check.
-            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192 /* Block */) {
+            // also if HasImplicitReturnValue flags is not set this means that all codepaths in function body end with return of throw
+            if (ts.nodeIsMissing(func.body) || func.body.kind !== 192 /* Block */ || !(func.flags & 524288 /* HasImplicitReturn */)) {
                 return;
             }
-            var bodyBlock = func.body;
-            // Ensure the body has at least one return expression.
-            if (bodyContainsAReturnStatement(bodyBlock)) {
-                return;
+            if (func.flags & 1048576 /* HasExplicitReturn */) {
+                if (compilerOptions.noImplicitReturns) {
+                    error(func.type, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                }
             }
-            // If there are no return expressions, then we need to check if
-            // the function body consists solely of a throw statement;
-            // this is to make an exception for unimplemented functions.
-            if (bodyContainsSingleThrowStatement(bodyBlock)) {
-                return;
+            else {
+                // This function does not conform to the specification.
+                error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
             }
-            // This function does not conform to the specification.
-            error(func.type, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement);
         }
         function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) {
             ts.Debug.assert(node.kind !== 143 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
@@ -22120,7 +22557,7 @@ var ts;
                 promisedType = checkAsyncFunctionReturnType(node);
             }
             if (returnType && !node.asteriskToken) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (node.body) {
                 if (!node.type) {
@@ -22205,7 +22642,7 @@ var ts;
                     case 69 /* Identifier */:
                     case 166 /* PropertyAccessExpression */: {
                         var symbol = findSymbol(n);
-                        return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 32768 /* Const */) !== 0;
+                        return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & 16384 /* Const */) !== 0;
                     }
                     case 167 /* ElementAccessExpression */: {
                         var index = n.argumentExpression;
@@ -22213,7 +22650,7 @@ var ts;
                         if (symbol && index && index.kind === 9 /* StringLiteral */) {
                             var name_12 = index.text;
                             var prop = getPropertyOfType(getTypeOfSymbol(symbol), name_12);
-                            return prop && (prop.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 32768 /* Const */) !== 0;
+                            return prop && (prop.flags & 3 /* Variable */) !== 0 && (getDeclarationFlagsFromSymbol(prop) & 16384 /* Const */) !== 0;
                         }
                         return false;
                     }
@@ -22298,8 +22735,8 @@ var ts;
             }
             if (type.flags & 49152 /* UnionOrIntersection */) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
+                    var current = types_9[_i];
                     if (current.flags & kind) {
                         return true;
                     }
@@ -22315,8 +22752,8 @@ var ts;
             }
             if (type.flags & 49152 /* UnionOrIntersection */) {
                 var types = type.types;
-                for (var _i = 0; _i < types.length; _i++) {
-                    var current = types[_i];
+                for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
+                    var current = types_10[_i];
                     if (!(current.flags & kind)) {
                         return false;
                     }
@@ -22361,8 +22798,8 @@ var ts;
         }
         function checkObjectLiteralAssignment(node, sourceType, contextualMapper) {
             var properties = node.properties;
-            for (var _i = 0; _i < properties.length; _i++) {
-                var p = properties[_i];
+            for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
+                var p = properties_3[_i];
                 if (p.kind === 245 /* PropertyAssignment */ || p.kind === 246 /* ShorthandPropertyAssignment */) {
                     // TODO(andersh): Computed property support
                     var name_13 = p.name;
@@ -22896,7 +23333,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             checkVariableLikeDeclaration(node);
             var func = ts.getContainingFunction(node);
-            if (node.flags & 112 /* AccessibilityModifier */) {
+            if (node.flags & 56 /* AccessibilityModifier */) {
                 func = ts.getContainingFunction(node);
                 if (!(func.kind === 144 /* Constructor */ && ts.nodeIsPresent(func.body))) {
                     error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
@@ -23096,7 +23533,7 @@ var ts;
             checkFunctionLikeDeclaration(node);
             // Abstract methods cannot have an implementation.
             // Extra checks are to avoid reporting multiple errors relating to the "abstractness" of the node.
-            if (node.flags & 256 /* Abstract */ && node.body) {
+            if (node.flags & 128 /* Abstract */ && node.body) {
                 error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
             }
         }
@@ -23147,7 +23584,7 @@ var ts;
             }
             function isInstancePropertyWithInitializer(n) {
                 return n.kind === 141 /* PropertyDeclaration */ &&
-                    !(n.flags & 128 /* Static */) &&
+                    !(n.flags & 64 /* Static */) &&
                     !!n.initializer;
             }
             // TS 1.0 spec (April 2014): 8.3.2
@@ -23168,14 +23605,14 @@ var ts;
                     // - The constructor declares parameter properties
                     //   or the containing class declares instance member variables with initializers.
                     var superCallShouldBeFirst = ts.forEach(node.parent.members, isInstancePropertyWithInitializer) ||
-                        ts.forEach(node.parameters, function (p) { return p.flags & (16 /* Public */ | 32 /* Private */ | 64 /* Protected */); });
+                        ts.forEach(node.parameters, function (p) { return p.flags & (8 /* Public */ | 16 /* Private */ | 32 /* Protected */); });
                     // Skip past any prologue directives to find the first statement
                     // to ensure that it was a super call.
                     if (superCallShouldBeFirst) {
                         var statements = node.body.statements;
                         var superCallStatement;
-                        for (var _i = 0; _i < statements.length; _i++) {
-                            var statement = statements[_i];
+                        for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) {
+                            var statement = statements_2[_i];
                             if (statement.kind === 195 /* ExpressionStatement */ && isSuperCallExpression(statement.expression)) {
                                 superCallStatement = statement;
                                 break;
@@ -23203,8 +23640,15 @@ var ts;
                 // Grammar checking accessors
                 checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
                 if (node.kind === 145 /* GetAccessor */) {
-                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) {
-                        error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);
+                    if (!ts.isInAmbientContext(node) && ts.nodeIsPresent(node.body) && (node.flags & 524288 /* HasImplicitReturn */)) {
+                        if (node.flags & 1048576 /* HasExplicitReturn */) {
+                            if (compilerOptions.noImplicitReturns) {
+                                error(node.name, ts.Diagnostics.Not_all_code_paths_return_a_value);
+                            }
+                        }
+                        else {
+                            error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value);
+                        }
                     }
                 }
                 if (!ts.hasDynamicName(node)) {
@@ -23213,7 +23657,7 @@ var ts;
                     var otherKind = node.kind === 145 /* GetAccessor */ ? 146 /* SetAccessor */ : 145 /* GetAccessor */;
                     var otherAccessor = ts.getDeclarationOfKind(node.symbol, otherKind);
                     if (otherAccessor) {
-                        if (((node.flags & 112 /* AccessibilityModifier */) !== (otherAccessor.flags & 112 /* AccessibilityModifier */))) {
+                        if (((node.flags & 56 /* AccessibilityModifier */) !== (otherAccessor.flags & 56 /* AccessibilityModifier */))) {
                             error(node.name, ts.Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
                         }
                         var currentAccessorType = getAnnotatedAccessorType(node);
@@ -23284,7 +23728,7 @@ var ts;
             ts.forEach(node.types, checkSourceElement);
         }
         function isPrivateWithinAmbient(node) {
-            return (node.flags & 32 /* Private */) && ts.isInAmbientContext(node);
+            return (node.flags & 16 /* Private */) && ts.isInAmbientContext(node);
         }
         function checkSpecializedSignatureDeclaration(signatureDeclarationNode) {
             if (!produceDiagnostics) {
@@ -23316,8 +23760,8 @@ var ts;
             else {
                 signaturesToCheck = getSignaturesOfSymbol(getSymbolOfNode(signatureDeclarationNode));
             }
-            for (var _i = 0; _i < signaturesToCheck.length; _i++) {
-                var otherSignature = signaturesToCheck[_i];
+            for (var _i = 0, signaturesToCheck_1 = signaturesToCheck; _i < signaturesToCheck_1.length; _i++) {
+                var otherSignature = signaturesToCheck_1[_i];
                 if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) {
                     return;
                 }
@@ -23332,11 +23776,11 @@ var ts;
                 n.parent.kind !== 214 /* ClassDeclaration */ &&
                 n.parent.kind !== 186 /* ClassExpression */ &&
                 ts.isInAmbientContext(n)) {
-                if (!(flags & 2 /* Ambient */)) {
+                if (!(flags & 4 /* Ambient */)) {
                     // It is nested in an ambient context, which means it is automatically exported
-                    flags |= 1 /* Export */;
+                    flags |= 2 /* Export */;
                 }
-                flags |= 2 /* Ambient */;
+                flags |= 4 /* Ambient */;
             }
             return flags & flagsToCheck;
         }
@@ -23361,16 +23805,16 @@ var ts;
                     var canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
                     ts.forEach(overloads, function (o) {
                         var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags;
-                        if (deviation & 1 /* Export */) {
+                        if (deviation & 2 /* Export */) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported);
                         }
-                        else if (deviation & 2 /* Ambient */) {
+                        else if (deviation & 4 /* Ambient */) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
                         }
-                        else if (deviation & (32 /* Private */ | 64 /* Protected */)) {
+                        else if (deviation & (16 /* Private */ | 32 /* Protected */)) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
                         }
-                        else if (deviation & 256 /* Abstract */) {
+                        else if (deviation & 128 /* Abstract */) {
                             error(o.name, ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_not_abstract);
                         }
                     });
@@ -23387,7 +23831,7 @@ var ts;
                     });
                 }
             }
-            var flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 32 /* Private */ | 64 /* Protected */ | 256 /* Abstract */;
+            var flagsToCheck = 2 /* Export */ | 4 /* Ambient */ | 16 /* Private */ | 32 /* Protected */ | 128 /* Abstract */;
             var someNodeFlags = 0;
             var allNodeFlags = flagsToCheck;
             var someHaveQuestionToken = false;
@@ -23418,8 +23862,8 @@ var ts;
                         if (node.name && subsequentNode.name && node.name.text === subsequentNode.name.text) {
                             // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members
                             ts.Debug.assert(node.kind === 143 /* MethodDeclaration */ || node.kind === 142 /* MethodSignature */);
-                            ts.Debug.assert((node.flags & 128 /* Static */) !== (subsequentNode.flags & 128 /* Static */));
-                            var diagnostic = node.flags & 128 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
+                            ts.Debug.assert((node.flags & 64 /* Static */) !== (subsequentNode.flags & 64 /* Static */));
+                            var diagnostic = node.flags & 64 /* Static */ ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static;
                             error(errorNode_1, diagnostic);
                             return;
                         }
@@ -23436,7 +23880,7 @@ var ts;
                 else {
                     // Report different errors regarding non-consecutive blocks of declarations depending on whether
                     // the node in question is abstract.
-                    if (node.flags & 256 /* Abstract */) {
+                    if (node.flags & 128 /* Abstract */) {
                         error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
                     }
                     else {
@@ -23449,8 +23893,8 @@ var ts;
             var isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & 1536 /* Module */;
             var duplicateFunctionDeclaration = false;
             var multipleConstructorImplementation = false;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var current = declarations[_i];
+            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                var current = declarations_4[_i];
                 var node = current;
                 var inAmbientContext = ts.isInAmbientContext(node);
                 var inAmbientContextOrInterface = node.parent.kind === 215 /* InterfaceDeclaration */ || node.parent.kind === 155 /* TypeLiteral */ || inAmbientContext;
@@ -23507,7 +23951,7 @@ var ts;
             }
             // Abstract methods can't have an implementation -- in particular, they don't need one.
             if (!isExportSymbolInsideModule && lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body &&
-                !(lastSeenNonAmbientDeclaration.flags & 256 /* Abstract */)) {
+                !(lastSeenNonAmbientDeclaration.flags & 128 /* Abstract */)) {
                 reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
             }
             if (hasOverloads) {
@@ -23533,8 +23977,8 @@ var ts;
                         // function g(x: string, y: string) { }
                         //
                         // The implementation is completely unrelated to the specialized signature, yet we do not check this.
-                        for (var _a = 0; _a < signatures.length; _a++) {
-                            var signature = signatures[_a];
+                        for (var _a = 0, signatures_3 = signatures; _a < signatures_3.length; _a++) {
+                            var signature = signatures_3[_a];
                             if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) {
                                 error(signature.declaration, ts.Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
                                 break;
@@ -23571,9 +24015,9 @@ var ts;
             for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) {
                 var d = _a[_i];
                 var declarationSpaces = getDeclarationSpaces(d);
-                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 1024 /* Default */);
-                if (effectiveDeclarationFlags & 1 /* Export */) {
-                    if (effectiveDeclarationFlags & 1024 /* Default */) {
+                var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 2 /* Export */ | 512 /* Default */);
+                if (effectiveDeclarationFlags & 2 /* Export */) {
+                    if (effectiveDeclarationFlags & 512 /* Default */) {
                         defaultExportedDeclarationSpaces |= declarationSpaces;
                     }
                     else {
@@ -23826,9 +24270,12 @@ var ts;
                 // type as a value. As such, we will just return unknownType;
                 return unknownType;
             }
-            var promiseConstructor = getMergedSymbol(promiseType.symbol);
+            var promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
             if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
-                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType));
+                var typeName = promiseConstructor
+                    ? symbolToString(promiseConstructor)
+                    : typeToString(promiseType);
+                error(node, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeName);
                 return unknownType;
             }
             // Validate the promise constructor type.
@@ -24020,7 +24467,7 @@ var ts;
                 if (isAsync) {
                     promisedType = checkAsyncFunctionReturnType(node);
                 }
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
             if (produceDiagnostics && !node.type) {
                 // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
@@ -24162,7 +24609,7 @@ var ts;
             //          let x = 0; // symbol for this declaration will be 'symbol'
             //      }
             // skip block-scoped variables and parameters
-            if ((ts.getCombinedNodeFlags(node) & 49152 /* BlockScoped */) !== 0 || ts.isParameterDeclaration(node)) {
+            if ((ts.getCombinedNodeFlags(node) & 24576 /* BlockScoped */) !== 0 || ts.isParameterDeclaration(node)) {
                 return;
             }
             // skip variable declarations that don't have initializers
@@ -24177,7 +24624,7 @@ var ts;
                 if (localDeclarationSymbol &&
                     localDeclarationSymbol !== symbol &&
                     localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) {
-                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 49152 /* BlockScoped */) {
+                    if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & 24576 /* BlockScoped */) {
                         var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 212 /* VariableDeclarationList */);
                         var container = varDeclList.parent.kind === 193 /* VariableStatement */ && varDeclList.parent.parent
                             ? varDeclList.parent.parent
@@ -24330,6 +24777,9 @@ var ts;
             checkGrammarStatementInAmbientContext(node);
             checkExpression(node.expression);
             checkSourceElement(node.thenStatement);
+            if (node.thenStatement.kind === 194 /* EmptyStatement */) {
+                error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
+            }
             checkSourceElement(node.elseStatement);
         }
         function checkDoStatement(node) {
@@ -24688,7 +25138,7 @@ var ts;
                         error(node.expression, ts.Diagnostics.Setters_cannot_return_a_value);
                     }
                     else if (func.kind === 144 /* Constructor */) {
-                        if (!isTypeAssignableTo(exprType, returnType)) {
+                        if (!checkTypeAssignableTo(exprType, returnType, node.expression)) {
                             error(node.expression, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
                         }
                     }
@@ -24835,7 +25285,7 @@ var ts;
                         // Only process instance properties with computed names here.
                         // Static properties cannot be in conflict with indexers,
                         // and properties with literal names were already checked.
-                        if (!(member.flags & 128 /* Static */) && ts.hasDynamicName(member)) {
+                        if (!(member.flags & 64 /* Static */) && ts.hasDynamicName(member)) {
                             var propType = getTypeOfSymbol(member.symbol);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, 0 /* String */);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, 1 /* Number */);
@@ -24921,7 +25371,7 @@ var ts;
             return getTypeOfSymbol(getSymbolOfNode(node));
         }
         function checkClassDeclaration(node) {
-            if (!node.name && !(node.flags & 1024 /* Default */)) {
+            if (!node.name && !(node.flags & 512 /* Default */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
             }
             checkClassLikeDeclaration(node);
@@ -24975,8 +25425,8 @@ var ts;
             }
             var implementedTypeNodes = ts.getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
-                for (var _b = 0; _b < implementedTypeNodes.length; _b++) {
-                    var typeRefNode = implementedTypeNodes[_b];
+                for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
+                    var typeRefNode = implementedTypeNodes_1[_b];
                     if (!ts.isSupportedExpressionWithTypeArguments(typeRefNode)) {
                         error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
@@ -25024,8 +25474,8 @@ var ts;
             // derived class instance member variables and accessors, but not by other kinds of members.
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfObjectType(baseType);
-            for (var _i = 0; _i < baseProperties.length; _i++) {
-                var baseProperty = baseProperties[_i];
+            for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
+                var baseProperty = baseProperties_1[_i];
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 134217728 /* Prototype */) {
                     continue;
@@ -25043,7 +25493,7 @@ var ts;
                         // It is an error to inherit an abstract member without implementing it or being declared abstract.
                         // If there is no declaration for the derived class (as in the case of class expressions),
                         // then the class cannot be declared abstract.
-                        if (baseDeclarationFlags & 256 /* Abstract */ && (!derivedClassDecl || !(derivedClassDecl.flags & 256 /* Abstract */))) {
+                        if (baseDeclarationFlags & 128 /* Abstract */ && (!derivedClassDecl || !(derivedClassDecl.flags & 128 /* Abstract */))) {
                             if (derivedClassDecl.kind === 186 /* ClassExpression */) {
                                 error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType));
                             }
@@ -25055,11 +25505,11 @@ var ts;
                     else {
                         // derived overrides base.
                         var derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
-                        if ((baseDeclarationFlags & 32 /* Private */) || (derivedDeclarationFlags & 32 /* Private */)) {
+                        if ((baseDeclarationFlags & 16 /* Private */) || (derivedDeclarationFlags & 16 /* Private */)) {
                             // either base or derived property is private - not override, skip it
                             continue;
                         }
-                        if ((baseDeclarationFlags & 128 /* Static */) !== (derivedDeclarationFlags & 128 /* Static */)) {
+                        if ((baseDeclarationFlags & 64 /* Static */) !== (derivedDeclarationFlags & 64 /* Static */)) {
                             // value of 'static' is not the same for properties - not override, skip it
                             continue;
                         }
@@ -25130,11 +25580,11 @@ var ts;
             var seen = {};
             ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { seen[p.name] = { prop: p, containingType: type }; });
             var ok = true;
-            for (var _i = 0; _i < baseTypes.length; _i++) {
-                var base = baseTypes[_i];
+            for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {
+                var base = baseTypes_2[_i];
                 var properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var prop = properties[_a];
+                for (var _a = 0, properties_4 = properties; _a < properties_4.length; _a++) {
+                    var prop = properties_4[_a];
                     if (!ts.hasProperty(seen, prop.name)) {
                         seen[prop.name] = { prop: prop, containingType: base };
                     }
@@ -25431,8 +25881,8 @@ var ts;
         }
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
             var declarations = symbol.declarations;
-            for (var _i = 0; _i < declarations.length; _i++) {
-                var declaration = declarations[_i];
+            for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) {
+                var declaration = declarations_5[_i];
                 if ((declaration.kind === 214 /* ClassDeclaration */ ||
                     (declaration.kind === 213 /* FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) &&
                     !ts.isInAmbientContext(declaration)) {
@@ -25571,7 +26021,7 @@ var ts;
                 // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035 /* Modifier */)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022 /* Modifier */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers);
             }
             if (checkExternalImportOrExportDeclaration(node)) {
@@ -25599,7 +26049,7 @@ var ts;
             checkGrammarDecorators(node) || checkGrammarModifiers(node);
             if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
                 checkImportBinding(node);
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     markExportAsReferenced(node);
                 }
                 if (ts.isInternalModuleImportEqualsDeclaration(node)) {
@@ -25630,7 +26080,7 @@ var ts;
                 // If we hit an export in an illegal context, just bail out to avoid cascading errors.
                 return;
             }
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035 /* Modifier */)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022 /* Modifier */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers);
             }
             if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
@@ -25674,7 +26124,7 @@ var ts;
                 return;
             }
             // Grammar checking
-            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 2035 /* Modifier */)) {
+            if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && (node.flags & 1022 /* Modifier */)) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers);
             }
             if (node.expression.kind === 69 /* Identifier */) {
@@ -26087,7 +26537,7 @@ var ts;
                             // add the type parameters into the symbol table
                             // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol.
                             // Note: that the memberFlags come from previous iteration.
-                            if (!(memberFlags & 128 /* Static */)) {
+                            if (!(memberFlags & 64 /* Static */)) {
                                 copySymbols(getSymbolOfNode(location).members, meaning & 793056 /* Type */);
                             }
                             break;
@@ -26388,7 +26838,7 @@ var ts;
           */
         function getParentTypeOfClassElement(node) {
             var classSymbol = getSymbolOfNode(node.parent);
-            return node.flags & 128 /* Static */
+            return node.flags & 64 /* Static */
                 ? getTypeOfSymbol(classSymbol)
                 : getDeclaredTypeOfSymbol(classSymbol);
         }
@@ -26709,7 +27159,7 @@ var ts;
         function initializeTypeChecker() {
             // Bind all source files and propagate errors
             ts.forEach(host.getSourceFiles(), function (file) {
-                ts.bindSourceFile(file);
+                ts.bindSourceFile(file, compilerOptions);
             });
             // Initialize global symbol table
             ts.forEach(host.getSourceFiles(), function (file) {
@@ -26863,19 +27313,19 @@ var ts;
                             text = "private";
                             lastPrivate = modifier;
                         }
-                        if (flags & 112 /* AccessibilityModifier */) {
+                        if (flags & 56 /* AccessibilityModifier */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen);
                         }
-                        else if (flags & 128 /* Static */) {
+                        else if (flags & 64 /* Static */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
                         }
                         else if (node.parent.kind === 219 /* ModuleBlock */ || node.parent.kind === 248 /* SourceFile */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_element, text);
                         }
-                        else if (flags & 256 /* Abstract */) {
+                        else if (flags & 128 /* Abstract */) {
                             if (modifier.kind === 110 /* PrivateKeyword */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
                             }
@@ -26886,10 +27336,10 @@ var ts;
                         flags |= ts.modifierToFlag(modifier.kind);
                         break;
                     case 113 /* StaticKeyword */:
-                        if (flags & 128 /* Static */) {
+                        if (flags & 64 /* Static */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
                         }
                         else if (node.parent.kind === 219 /* ModuleBlock */ || node.parent.kind === 248 /* SourceFile */) {
@@ -26898,23 +27348,23 @@ var ts;
                         else if (node.kind === 138 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
                         }
-                        else if (flags & 256 /* Abstract */) {
+                        else if (flags & 128 /* Abstract */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                         }
-                        flags |= 128 /* Static */;
+                        flags |= 64 /* Static */;
                         lastStatic = modifier;
                         break;
                     case 82 /* ExportKeyword */:
-                        if (flags & 1 /* Export */) {
+                        if (flags & 2 /* Export */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export");
                         }
-                        else if (flags & 2 /* Ambient */) {
+                        else if (flags & 4 /* Ambient */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
                         }
-                        else if (flags & 256 /* Abstract */) {
+                        else if (flags & 128 /* Abstract */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
                         }
                         else if (node.parent.kind === 214 /* ClassDeclaration */) {
@@ -26923,13 +27373,13 @@ var ts;
                         else if (node.kind === 138 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
                         }
-                        flags |= 1 /* Export */;
+                        flags |= 2 /* Export */;
                         break;
                     case 122 /* DeclareKeyword */:
-                        if (flags & 2 /* Ambient */) {
+                        if (flags & 4 /* Ambient */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare");
                         }
-                        else if (flags & 512 /* Async */) {
+                        else if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.parent.kind === 214 /* ClassDeclaration */) {
@@ -26941,69 +27391,69 @@ var ts;
                         else if (ts.isInAmbientContext(node.parent) && node.parent.kind === 219 /* ModuleBlock */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
                         }
-                        flags |= 2 /* Ambient */;
+                        flags |= 4 /* Ambient */;
                         lastDeclare = modifier;
                         break;
                     case 115 /* AbstractKeyword */:
-                        if (flags & 256 /* Abstract */) {
+                        if (flags & 128 /* Abstract */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract");
                         }
                         if (node.kind !== 214 /* ClassDeclaration */) {
                             if (node.kind !== 143 /* MethodDeclaration */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_or_method_declaration);
                             }
-                            if (!(node.parent.kind === 214 /* ClassDeclaration */ && node.parent.flags & 256 /* Abstract */)) {
+                            if (!(node.parent.kind === 214 /* ClassDeclaration */ && node.parent.flags & 128 /* Abstract */)) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
                             }
-                            if (flags & 128 /* Static */) {
+                            if (flags & 64 /* Static */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                             }
-                            if (flags & 32 /* Private */) {
+                            if (flags & 16 /* Private */) {
                                 return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
                             }
                         }
-                        flags |= 256 /* Abstract */;
+                        flags |= 128 /* Abstract */;
                         break;
                     case 118 /* AsyncKeyword */:
-                        if (flags & 512 /* Async */) {
+                        if (flags & 256 /* Async */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async");
                         }
-                        else if (flags & 2 /* Ambient */ || ts.isInAmbientContext(node.parent)) {
+                        else if (flags & 4 /* Ambient */ || ts.isInAmbientContext(node.parent)) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
                         }
                         else if (node.kind === 138 /* Parameter */) {
                             return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
                         }
-                        flags |= 512 /* Async */;
+                        flags |= 256 /* Async */;
                         lastAsync = modifier;
                         break;
                 }
             }
             if (node.kind === 144 /* Constructor */) {
-                if (flags & 128 /* Static */) {
+                if (flags & 64 /* Static */) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
                 }
-                if (flags & 256 /* Abstract */) {
+                if (flags & 128 /* Abstract */) {
                     return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "abstract");
                 }
-                else if (flags & 64 /* Protected */) {
+                else if (flags & 32 /* Protected */) {
                     return grammarErrorOnNode(lastProtected, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "protected");
                 }
-                else if (flags & 32 /* Private */) {
+                else if (flags & 16 /* Private */) {
                     return grammarErrorOnNode(lastPrivate, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "private");
                 }
-                else if (flags & 512 /* Async */) {
+                else if (flags & 256 /* Async */) {
                     return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
                 }
                 return;
             }
-            else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
+            else if ((node.kind === 222 /* ImportDeclaration */ || node.kind === 221 /* ImportEqualsDeclaration */) && flags & 4 /* Ambient */) {
                 return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
             }
-            else if (node.kind === 138 /* Parameter */ && (flags & 112 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) {
+            else if (node.kind === 138 /* Parameter */ && (flags & 56 /* AccessibilityModifier */) && ts.isBindingPattern(node.name)) {
                 return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_a_binding_pattern);
             }
-            if (flags & 512 /* Async */) {
+            if (flags & 256 /* Async */) {
                 return checkGrammarAsyncModifier(node, lastAsync);
             }
         }
@@ -27104,7 +27554,7 @@ var ts;
             if (parameter.dotDotDotToken) {
                 return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
             }
-            if (parameter.flags & 2035 /* Modifier */) {
+            if (parameter.flags & 1022 /* Modifier */) {
                 return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
             }
             if (parameter.questionToken) {
@@ -27124,7 +27574,7 @@ var ts;
             }
         }
         function checkGrammarForIndexSignatureModifier(node) {
-            if (node.flags & 2035 /* Modifier */) {
+            if (node.flags & 1022 /* Modifier */) {
                 grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_not_permitted_on_index_signature_members);
             }
         }
@@ -27147,8 +27597,8 @@ var ts;
         function checkGrammarForOmittedArgument(node, args) {
             if (args) {
                 var sourceFile = ts.getSourceFileOfNode(node);
-                for (var _i = 0; _i < args.length; _i++) {
-                    var arg = args[_i];
+                for (var _i = 0, args_1 = args; _i < args_1.length; _i++) {
+                    var arg = args_1[_i];
                     if (arg.kind === 187 /* OmittedExpression */) {
                         return grammarErrorAtPos(sourceFile, arg.pos, 0, ts.Diagnostics.Argument_expression_expected);
                     }
@@ -27403,7 +27853,7 @@ var ts;
                     if (parameter.dotDotDotToken) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter);
                     }
-                    else if (parameter.flags & 2035 /* Modifier */) {
+                    else if (parameter.flags & 1022 /* Modifier */) {
                         return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
                     }
                     else if (parameter.questionToken) {
@@ -27554,8 +28004,8 @@ var ts;
             }
             else {
                 var elements = name.elements;
-                for (var _i = 0; _i < elements.length; _i++) {
-                    var element = elements[_i];
+                for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) {
+                    var element = elements_2[_i];
                     if (element.kind !== 187 /* OmittedExpression */) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -27691,8 +28141,8 @@ var ts;
                 node.kind === 221 /* ImportEqualsDeclaration */ ||
                 node.kind === 228 /* ExportDeclaration */ ||
                 node.kind === 227 /* ExportAssignment */ ||
-                (node.flags & 2 /* Ambient */) ||
-                (node.flags & (1 /* Export */ | 1024 /* Default */))) {
+                (node.flags & 4 /* Ambient */) ||
+                (node.flags & (2 /* Export */ | 512 /* Default */))) {
                 return false;
             }
             return grammarErrorOnFirstToken(node, ts.Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
@@ -27739,7 +28189,7 @@ var ts;
         }
         function checkGrammarNumericLiteral(node) {
             // Grammar checking
-            if (node.flags & 65536 /* OctalLiteral */ && languageVersion >= 1 /* ES5 */) {
+            if (node.flags & 32768 /* OctalLiteral */ && languageVersion >= 1 /* ES5 */) {
                 return grammarErrorOnNode(node, ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher);
             }
         }
@@ -27793,7 +28243,7 @@ var ts;
                 ts.forEach(root.referencedFiles, function (fileReference) {
                     var referencedFile = ts.tryResolveScriptReference(host, root, fileReference);
                     // All the references that are not going to be part of same file
-                    if (referencedFile && ((referencedFile.flags & 8192 /* DeclarationFile */) ||
+                    if (referencedFile && ((referencedFile.flags & 4096 /* DeclarationFile */) ||
                         ts.shouldEmitToOwnFile(referencedFile, compilerOptions) ||
                         !addedGlobalFileReference)) {
                         writeReferencePath(referencedFile);
@@ -27988,15 +28438,15 @@ var ts;
             }
         }
         function emitLines(nodes) {
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                var node = nodes_2[_i];
                 emit(node);
             }
         }
         function emitSeparatedList(nodes, separator, eachNodeEmitFn, canEmitFn) {
             var currentWriterPos = writer.getTextPos();
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+                var node = nodes_3[_i];
                 if (!canEmitFn || canEmitFn(node)) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         write(separator);
@@ -28142,6 +28592,7 @@ var ts;
         function emitSourceFile(node) {
             currentSourceFile = node;
             enclosingDeclaration = node;
+            ts.emitDetachedComments(currentSourceFile, writer, ts.writeCommentRange, node, newLine, true /* remove comments */);
             emitLines(node.statements);
         }
         // Return a temp variable name to be used in `export default` statements.
@@ -28258,10 +28709,10 @@ var ts;
             // If the node is parented in the current source file we need to emit export declare or just export
             if (node.parent === currentSourceFile) {
                 // If the node is exported
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     write("export ");
                 }
-                if (node.flags & 1024 /* Default */) {
+                if (node.flags & 512 /* Default */) {
                     write("default ");
                 }
                 else if (node.kind !== 215 /* InterfaceDeclaration */) {
@@ -28270,16 +28721,16 @@ var ts;
             }
         }
         function emitClassMemberDeclarationFlags(node) {
-            if (node.flags & 32 /* Private */) {
+            if (node.flags & 16 /* Private */) {
                 write("private ");
             }
-            else if (node.flags & 64 /* Protected */) {
+            else if (node.flags & 32 /* Protected */) {
                 write("protected ");
             }
-            if (node.flags & 128 /* Static */) {
+            if (node.flags & 64 /* Static */) {
                 write("static ");
             }
-            if (node.flags & 256 /* Abstract */) {
+            if (node.flags & 128 /* Abstract */) {
                 write("abstract ");
             }
         }
@@ -28287,7 +28738,7 @@ var ts;
             // note usage of writer. methods instead of aliases created, just to make sure we are using
             // correct writer especially to handle asynchronous alias writing
             emitJsDocComments(node);
-            if (node.flags & 1 /* Export */) {
+            if (node.flags & 2 /* Export */) {
                 write("export ");
             }
             write("import ");
@@ -28322,12 +28773,12 @@ var ts;
             }
         }
         function writeImportDeclaration(node) {
-            if (!node.importClause && !(node.flags & 1 /* Export */)) {
+            if (!node.importClause && !(node.flags & 2 /* Export */)) {
                 // do not write non-exported import declarations that don't have import clauses
                 return;
             }
             emitJsDocComments(node);
-            if (node.flags & 1 /* Export */) {
+            if (node.flags & 2 /* Export */) {
                 write("export ");
             }
             write("import ");
@@ -28392,7 +28843,7 @@ var ts;
         function writeModuleDeclaration(node) {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 131072 /* Namespace */) {
+            if (node.flags & 65536 /* Namespace */) {
                 write("namespace ");
             }
             else {
@@ -28464,7 +28915,7 @@ var ts;
             writeLine();
         }
         function isPrivateMethodTypeParameter(node) {
-            return node.parent.kind === 143 /* MethodDeclaration */ && (node.parent.flags & 32 /* Private */);
+            return node.parent.kind === 143 /* MethodDeclaration */ && (node.parent.flags & 16 /* Private */);
         }
         function emitTypeParameters(typeParameters) {
             function emitTypeParameter(node) {
@@ -28508,7 +28959,7 @@ var ts;
                             break;
                         case 143 /* MethodDeclaration */:
                         case 142 /* MethodSignature */:
-                            if (node.parent.flags & 128 /* Static */) {
+                            if (node.parent.flags & 64 /* Static */) {
                                 diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                             }
                             else if (node.parent.parent.kind === 214 /* ClassDeclaration */) {
@@ -28574,7 +29025,7 @@ var ts;
             function emitParameterProperties(constructorDeclaration) {
                 if (constructorDeclaration) {
                     ts.forEach(constructorDeclaration.parameters, function (param) {
-                        if (param.flags & 112 /* AccessibilityModifier */) {
+                        if (param.flags & 56 /* AccessibilityModifier */) {
                             emitPropertyDeclaration(param);
                         }
                     });
@@ -28582,7 +29033,7 @@ var ts;
             }
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & 256 /* Abstract */) {
+            if (node.flags & 128 /* Abstract */) {
                 write("abstract ");
             }
             write("class ");
@@ -28652,7 +29103,7 @@ var ts;
                     if ((node.kind === 141 /* PropertyDeclaration */ || node.kind === 140 /* PropertySignature */) && node.parent.kind === 155 /* TypeLiteral */) {
                         emitTypeOfVariableDeclarationFromTypeLiteral(node);
                     }
-                    else if (!(node.flags & 32 /* Private */)) {
+                    else if (!(node.flags & 16 /* Private */)) {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
@@ -28667,7 +29118,7 @@ var ts;
                 }
                 else if (node.kind === 141 /* PropertyDeclaration */ || node.kind === 140 /* PropertySignature */) {
                     // TODO(jfreeman): Deal with computed properties in error reporting.
-                    if (node.flags & 128 /* Static */) {
+                    if (node.flags & 64 /* Static */) {
                         return symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                 ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -28771,7 +29222,7 @@ var ts;
                 emitJsDocComments(accessors.setAccessor);
                 emitClassMemberDeclarationFlags(node);
                 writeTextOfNode(currentSourceFile, node.name);
-                if (!(node.flags & 32 /* Private */)) {
+                if (!(node.flags & 16 /* Private */)) {
                     accessorWithTypeAnnotation = node;
                     var type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
@@ -28800,7 +29251,7 @@ var ts;
                 var diagnosticMessage;
                 if (accessorWithTypeAnnotation.kind === 146 /* SetAccessor */) {
                     // Setters have to have type named and cannot infer it so, the type should always be named
-                    if (accessorWithTypeAnnotation.parent.flags & 128 /* Static */) {
+                    if (accessorWithTypeAnnotation.parent.flags & 64 /* Static */) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                             ts.Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
@@ -28818,7 +29269,7 @@ var ts;
                     };
                 }
                 else {
-                    if (accessorWithTypeAnnotation.flags & 128 /* Static */) {
+                    if (accessorWithTypeAnnotation.flags & 64 /* Static */) {
                         diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                             symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                 ts.Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -28905,7 +29356,7 @@ var ts;
                     emitType(node.type);
                 }
             }
-            else if (node.kind !== 144 /* Constructor */ && !(node.flags & 32 /* Private */)) {
+            else if (node.kind !== 144 /* Constructor */ && !(node.flags & 16 /* Private */)) {
                 writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
             }
             enclosingDeclaration = prevEnclosingDeclaration;
@@ -28936,7 +29387,7 @@ var ts;
                         break;
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
-                        if (node.flags & 128 /* Static */) {
+                        if (node.flags & 64 /* Static */) {
                             diagnosticMessage = symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                     ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -28997,7 +29448,7 @@ var ts;
                 node.parent.parent.kind === 155 /* TypeLiteral */) {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
-            else if (!(node.parent.flags & 32 /* Private */)) {
+            else if (!(node.parent.flags & 16 /* Private */)) {
                 writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
             }
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult) {
@@ -29028,7 +29479,7 @@ var ts;
                             ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
-                        if (node.parent.flags & 128 /* Static */) {
+                        if (node.parent.flags & 64 /* Static */) {
                             return symbolAccesibilityResult.errorModuleName ?
                                 symbolAccesibilityResult.accessibility === 2 /* CannotBeNamed */ ?
                                     ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -29170,7 +29621,7 @@ var ts;
             }
         }
         function writeReferencePath(referencedFile) {
-            var declFileName = referencedFile.flags & 8192 /* DeclarationFile */
+            var declFileName = referencedFile.flags & 4096 /* DeclarationFile */
                 ? referencedFile.fileName // Declaration file, use declaration file name
                 : ts.shouldEmitToOwnFile(referencedFile, compilerOptions)
                     ? ts.getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file
@@ -29216,6 +29667,12 @@ var ts;
         return ts.isExternalModule(sourceFile) || ts.isDeclarationFile(sourceFile);
     }
     ts.isExternalModuleOrDeclarationFile = isExternalModuleOrDeclarationFile;
+    var Jump;
+    (function (Jump) {
+        Jump[Jump["Break"] = 2] = "Break";
+        Jump[Jump["Continue"] = 4] = "Continue";
+        Jump[Jump["Return"] = 8] = "Return";
+    })(Jump || (Jump = {}));
     var entities = {
         "quot": 0x0022,
         "amp": 0x0026,
@@ -29525,16 +29982,8 @@ var ts;
             diagnostics: diagnostics,
             sourceMaps: sourceMapDataList
         };
-        function isNodeDescendentOf(node, ancestor) {
-            while (node) {
-                if (node === ancestor)
-                    return true;
-                node = node.parent;
-            }
-            return false;
-        }
         function isUniqueLocalName(name, container) {
-            for (var node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {
+            for (var node = container; ts.isNodeDescendentOf(node, container); node = node.nextContainer) {
                 if (node.locals && ts.hasProperty(node.locals, name)) {
                     // We conservatively include alias symbols to cover cases where they're emitted as locals
                     if (node.locals[name].flags & (107455 /* Value */ | 1048576 /* ExportValue */ | 8388608 /* Alias */)) {
@@ -29544,12 +29993,6 @@ var ts;
             }
             return true;
         }
-        var Jump;
-        (function (Jump) {
-            Jump[Jump["Break"] = 2] = "Break";
-            Jump[Jump["Continue"] = 4] = "Continue";
-            Jump[Jump["Return"] = 8] = "Return";
-        })(Jump || (Jump = {}));
         function setLabeledJump(state, isBreak, labelText, labelMarker) {
             if (isBreak) {
                 if (!state.labeledNonLocalBreaks) {
@@ -31026,7 +31469,7 @@ var ts;
                     write("]");
                 }
                 else {
-                    emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/ (node.flags & 2048 /* MultiLine */) !== 0, 
+                    emitListWithSpread(elements, /*needsUniqueCopy*/ true, /*multiLine*/ (node.flags & 1024 /* MultiLine */) !== 0, 
                     /*trailingComma*/ elements.hasTrailingComma, /*useConcat*/ true);
                 }
             }
@@ -31045,7 +31488,7 @@ var ts;
                         emitLinePreservingList(node, properties, /* allowTrailingComma */ languageVersion >= 1 /* ES5 */, /* spacesBetweenBraces */ true);
                     }
                     else {
-                        var multiLine = (node.flags & 2048 /* MultiLine */) !== 0;
+                        var multiLine = (node.flags & 1024 /* MultiLine */) !== 0;
                         if (!multiLine) {
                             write(" ");
                         }
@@ -31064,7 +31507,7 @@ var ts;
                 write("}");
             }
             function emitDownlevelObjectLiteralWithComputedProperties(node, firstComputedPropertyIndex) {
-                var multiLine = (node.flags & 2048 /* MultiLine */) !== 0;
+                var multiLine = (node.flags & 1024 /* MultiLine */) !== 0;
                 var properties = node.properties;
                 write("(");
                 if (multiLine) {
@@ -31693,7 +32136,7 @@ var ts;
                 var current = node;
                 while (current) {
                     if (current.kind === 248 /* SourceFile */) {
-                        return !isExported || ((ts.getCombinedNodeFlags(node) & 1 /* Export */) !== 0);
+                        return !isExported || ((ts.getCombinedNodeFlags(node) & 2 /* Export */) !== 0);
                     }
                     else if (ts.isFunctionLike(current) || current.kind === 219 /* ModuleBlock */) {
                         return false;
@@ -31934,7 +32377,7 @@ var ts;
                     // variables in variable declaration list were already hoisted
                     return false;
                 }
-                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 49152 /* BlockScoped */) === 0) {
+                if (convertedLoopState && (ts.getCombinedNodeFlags(decl) & 24576 /* BlockScoped */) === 0) {
                     // we are inside a converted loop - this can only happen in downlevel scenarios 
                     // record names for all variable declarations
                     for (var _a = 0, _b = decl.declarations; _a < _b.length; _a++) {
@@ -32019,7 +32462,7 @@ var ts;
                         break;
                 }
                 var loopParameters;
-                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 49152 /* BlockScoped */)) {
+                if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 24576 /* BlockScoped */)) {
                     // if loop initializer contains block scoped variables - they should be passed to converted loop body as parameters
                     loopParameters = [];
                     for (var _a = 0, _b = loopInitializer.declarations; _a < _b.length; _a++) {
@@ -32334,10 +32777,12 @@ var ts;
                 //
                 //     for (let v of arr) { }
                 //
-                // we don't want to emit a temporary variable for the RHS, just use it directly.
-                var rhsIsIdentifier = node.expression.kind === 69 /* Identifier */;
+                // we can't reuse 'arr' because it might be modified within the body of the loop.
                 var counter = createTempVariable(268435456 /* _i */);
-                var rhsReference = rhsIsIdentifier ? node.expression : createTempVariable(0 /* Auto */);
+                var rhsReference = ts.createSynthesizedNode(69 /* Identifier */);
+                rhsReference.text = node.expression.kind === 69 /* Identifier */ ?
+                    makeUniqueName(node.expression.text) :
+                    makeTempVariableName(0 /* Auto */);
                 // This is the let keyword for the counter and rhsReference. The let keyword for
                 // the LHS will be emitted inside the body.
                 emitStart(node.expression);
@@ -32346,15 +32791,13 @@ var ts;
                 emitNodeWithoutSourceMap(counter);
                 write(" = 0");
                 emitEnd(node.expression);
-                if (!rhsIsIdentifier) {
-                    // , _a = expr
-                    write(", ");
-                    emitStart(node.expression);
-                    emitNodeWithoutSourceMap(rhsReference);
-                    write(" = ");
-                    emitNodeWithoutSourceMap(node.expression);
-                    emitEnd(node.expression);
-                }
+                // , _a = expr
+                write(", ");
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(rhsReference);
+                write(" = ");
+                emitNodeWithoutSourceMap(node.expression);
+                emitEnd(node.expression);
                 write("; ");
                 // _i < _a.length;
                 emitStart(node.initializer);
@@ -32609,7 +33052,7 @@ var ts;
             }
             function emitModuleMemberName(node) {
                 emitStart(node.name);
-                if (ts.getCombinedNodeFlags(node) & 1 /* Export */) {
+                if (ts.getCombinedNodeFlags(node) & 2 /* Export */) {
                     var container = getContainingModule(node);
                     if (container) {
                         write(getGeneratedNameForNode(container));
@@ -32631,7 +33074,7 @@ var ts;
             }
             function emitEs6ExportDefaultCompat(node) {
                 if (node.parent.kind === 248 /* SourceFile */) {
-                    ts.Debug.assert(!!(node.flags & 1024 /* Default */) || node.kind === 227 /* ExportAssignment */);
+                    ts.Debug.assert(!!(node.flags & 512 /* Default */) || node.kind === 227 /* ExportAssignment */);
                     // only allow export default at a source file level
                     if (modulekind === 1 /* CommonJS */ || modulekind === 2 /* AMD */ || modulekind === 3 /* UMD */) {
                         if (!currentSourceFile.symbol.exports["___esModule"]) {
@@ -32649,7 +33092,7 @@ var ts;
                 }
             }
             function emitExportMemberAssignment(node) {
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     writeLine();
                     emitStart(node);
                     // emit call to exporter only for top level nodes
@@ -32657,7 +33100,7 @@ var ts;
                         // emit export default <smth> as
                         // export("default", <smth>)
                         write(exportFunctionForFile + "(\"");
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             write("default");
                         }
                         else {
@@ -32668,7 +33111,7 @@ var ts;
                         write(")");
                     }
                     else {
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             emitEs6ExportDefaultCompat(node);
                             if (languageVersion === 0 /* ES3 */) {
                                 write("exports[\"default\"]");
@@ -32772,7 +33215,7 @@ var ts;
                 // because actual variable declarations are hoisted
                 var canDefineTempVariablesInPlace = false;
                 if (root.kind === 211 /* VariableDeclaration */) {
-                    var isExported = ts.getCombinedNodeFlags(root) & 1 /* Export */;
+                    var isExported = ts.getCombinedNodeFlags(root) & 2 /* Export */;
                     var isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
                     canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind;
                 }
@@ -32854,8 +33297,8 @@ var ts;
                         // to ensure value is evaluated exactly once.
                         value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     }
-                    for (var _a = 0; _a < properties.length; _a++) {
-                        var p = properties[_a];
+                    for (var _a = 0, properties_5 = properties; _a < properties_5.length; _a++) {
+                        var p = properties_5[_a];
                         if (p.kind === 245 /* PropertyAssignment */ || p.kind === 246 /* ShorthandPropertyAssignment */) {
                             var propName = p.name;
                             var target_1 = p.kind === 246 /* ShorthandPropertyAssignment */ ? p : p.initializer || propName;
@@ -32990,7 +33433,7 @@ var ts;
                         // this is necessary to preserve ES6 semantic in scenarios like
                         // for (...) { let x; console.log(x); x = 1 } // assignment on one iteration should not affect other iterations
                         var isLetDefinedInLoop = (resolver.getNodeCheckFlags(node) & 16384 /* BlockScopedBindingInLoop */) &&
-                            (getCombinedFlagsForIdentifier(node.name) & 16384 /* Let */);
+                            (getCombinedFlagsForIdentifier(node.name) & 8192 /* Let */);
                         // NOTE: default initialization should not be added to let bindings in for-in\for-of statements
                         if (isLetDefinedInLoop &&
                             node.parent.parent.kind !== 200 /* ForInStatement */ &&
@@ -33030,13 +33473,13 @@ var ts;
                 return ts.getCombinedNodeFlags(node.parent);
             }
             function isES6ExportedDeclaration(node) {
-                return !!(node.flags & 1 /* Export */) &&
+                return !!(node.flags & 2 /* Export */) &&
                     modulekind === 5 /* ES6 */ &&
                     node.parent.kind === 248 /* SourceFile */;
             }
             function emitVariableStatement(node) {
                 var startIsEmitted = false;
-                if (node.flags & 1 /* Export */) {
+                if (node.flags & 2 /* Export */) {
                     if (isES6ExportedDeclaration(node)) {
                         // Exported ES6 module member
                         write("export ");
@@ -33063,7 +33506,7 @@ var ts;
             function shouldEmitLeadingAndTrailingCommentsForVariableStatement(node) {
                 // If we're not exporting the variables, there's nothing special here.
                 // Always emit comments for these nodes.
-                if (!(node.flags & 1 /* Export */)) {
+                if (!(node.flags & 2 /* Export */)) {
                     return true;
                 }
                 // If we are exporting, but it's a top-level ES6 module exports,
@@ -33246,7 +33689,7 @@ var ts;
                 if (!shouldEmitAsArrowFunction(node)) {
                     if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             write("default ");
                         }
                     }
@@ -33466,7 +33909,7 @@ var ts;
                 emitRestParameter(node);
             }
             function emitExpressionFunctionBody(node, body) {
-                if (languageVersion < 2 /* ES6 */ || node.flags & 512 /* Async */) {
+                if (languageVersion < 2 /* ES6 */ || node.flags & 256 /* Async */) {
                     emitDownLevelExpressionFunctionBody(node, body);
                     return;
                 }
@@ -33487,7 +33930,7 @@ var ts;
                 scopeEmitStart(node);
                 increaseIndent();
                 var outPos = writer.getTextPos();
-                emitDetachedComments(node.body);
+                emitDetachedCommentsAndUpdateCommentsInfo(node.body);
                 emitFunctionBodyPreamble(node);
                 var preambleEmitted = writer.getTextPos() !== outPos;
                 decreaseIndent();
@@ -33525,7 +33968,7 @@ var ts;
                 scopeEmitStart(node);
                 var initialTextPos = writer.getTextPos();
                 increaseIndent();
-                emitDetachedComments(body.statements);
+                emitDetachedCommentsAndUpdateCommentsInfo(body.statements);
                 // Emit all the directive prologues (like "use strict").  These have to come before
                 // any other preamble code we write (like parameter initializers).
                 var startIndex = emitDirectivePrologues(body.statements, /*startWithNewLine*/ true);
@@ -33569,7 +34012,7 @@ var ts;
             }
             function emitParameterPropertyAssignments(node) {
                 ts.forEach(node.parameters, function (param) {
-                    if (param.flags & 112 /* AccessibilityModifier */) {
+                    if (param.flags & 56 /* AccessibilityModifier */) {
                         writeLine();
                         emitStart(param);
                         emitStart(param.name);
@@ -33604,15 +34047,15 @@ var ts;
                 var properties = [];
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
-                    if (member.kind === 141 /* PropertyDeclaration */ && isStatic === ((member.flags & 128 /* Static */) !== 0) && member.initializer) {
+                    if (member.kind === 141 /* PropertyDeclaration */ && isStatic === ((member.flags & 64 /* Static */) !== 0) && member.initializer) {
                         properties.push(member);
                     }
                 }
                 return properties;
             }
             function emitPropertyDeclarations(node, properties) {
-                for (var _a = 0; _a < properties.length; _a++) {
-                    var property = properties[_a];
+                for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) {
+                    var property = properties_6[_a];
                     emitPropertyDeclaration(node, property);
                 }
             }
@@ -33625,7 +34068,7 @@ var ts;
                     emit(receiver);
                 }
                 else {
-                    if (property.flags & 128 /* Static */) {
+                    if (property.flags & 64 /* Static */) {
                         emitDeclarationName(node);
                     }
                     else {
@@ -33724,7 +34167,7 @@ var ts;
                         writeLine();
                         emitLeadingComments(member);
                         emitStart(member);
-                        if (member.flags & 128 /* Static */) {
+                        if (member.flags & 64 /* Static */) {
                             write("static ");
                         }
                         if (member.kind === 145 /* GetAccessor */) {
@@ -33774,7 +34217,7 @@ var ts;
                         emitCommentsOnNotEmittedNode(member);
                     }
                     // Check if there is any non-static property assignment
-                    if (member.kind === 141 /* PropertyDeclaration */ && member.initializer && (member.flags & 128 /* Static */) === 0) {
+                    if (member.kind === 141 /* PropertyDeclaration */ && member.initializer && (member.flags & 64 /* Static */) === 0) {
                         hasInstancePropertyWithInitializer = true;
                     }
                 });
@@ -33821,7 +34264,7 @@ var ts;
                     // Emit all the directive prologues (like "use strict").  These have to come before
                     // any other preamble code we write (like parameter initializers).
                     startIndex = emitDirectivePrologues(ctor.body.statements, /*startWithNewLine*/ true);
-                    emitDetachedComments(ctor.body.statements);
+                    emitDetachedCommentsAndUpdateCommentsInfo(ctor.body.statements);
                 }
                 emitCaptureThisForNodeIfNecessary(node);
                 var superCall;
@@ -33941,7 +34384,7 @@ var ts;
                         //     _default = __decorate([dec], _default);
                         //     export default _default;
                         //
-                        if (isES6ExportedDeclaration(node) && !(node.flags & 1024 /* Default */)) {
+                        if (isES6ExportedDeclaration(node) && !(node.flags & 512 /* Default */)) {
                             write("export ");
                         }
                         write("let ");
@@ -33950,7 +34393,7 @@ var ts;
                     }
                     else if (isES6ExportedDeclaration(node)) {
                         write("export ");
-                        if (node.flags & 1024 /* Default */) {
+                        if (node.flags & 512 /* Default */) {
                             write("default ");
                         }
                     }
@@ -33980,7 +34423,7 @@ var ts;
                 // emit name if
                 // - node has a name
                 // - this is default export with static initializers
-                if ((node.name || (node.flags & 1024 /* Default */ && staticProperties.length > 0)) && !thisNodeIsDecorated) {
+                if ((node.name || (node.flags & 512 /* Default */ && staticProperties.length > 0)) && !thisNodeIsDecorated) {
                     write(" ");
                     emitDeclarationName(node);
                 }
@@ -34016,8 +34459,8 @@ var ts;
                 //      HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using
                 //                                  a lexical declaration such as a LexicalDeclaration or a ClassDeclaration.
                 if (isClassExpressionWithStaticProperties) {
-                    for (var _a = 0; _a < staticProperties.length; _a++) {
-                        var property = staticProperties[_a];
+                    for (var _a = 0, staticProperties_1 = staticProperties; _a < staticProperties_1.length; _a++) {
+                        var property = staticProperties_1[_a];
                         write(",");
                         writeLine();
                         emitPropertyDeclaration(node, property, /*receiver:*/ tempVariable, /*isExpression:*/ true);
@@ -34035,7 +34478,7 @@ var ts;
                 }
                 // If this is an exported class, but not on the top level (i.e. on an internal
                 // module), export it
-                if (!isES6ExportedDeclaration(node) && (node.flags & 1 /* Export */)) {
+                if (!isES6ExportedDeclaration(node) && (node.flags & 2 /* Export */)) {
                     writeLine();
                     emitStart(node);
                     emitModuleMemberName(node);
@@ -34044,7 +34487,7 @@ var ts;
                     emitEnd(node);
                     write(";");
                 }
-                else if (isES6ExportedDeclaration(node) && (node.flags & 1024 /* Default */) && thisNodeIsDecorated) {
+                else if (isES6ExportedDeclaration(node) && (node.flags & 512 /* Default */) && thisNodeIsDecorated) {
                     // if this is a top level default export of decorated class, write the export after the declaration.
                     writeLine();
                     write("export default ");
@@ -34126,13 +34569,13 @@ var ts;
             }
             function emitClassMemberPrefix(node, member) {
                 emitDeclarationName(node);
-                if (!(member.flags & 128 /* Static */)) {
+                if (!(member.flags & 64 /* Static */)) {
                     write(".prototype");
                 }
             }
             function emitDecoratorsOfClass(node) {
                 emitDecoratorsOfMembers(node, /*staticFlag*/ 0);
-                emitDecoratorsOfMembers(node, 128 /* Static */);
+                emitDecoratorsOfMembers(node, 64 /* Static */);
                 emitDecoratorsOfConstructor(node);
             }
             function emitDecoratorsOfConstructor(node) {
@@ -34179,7 +34622,7 @@ var ts;
                 for (var _a = 0, _b = node.members; _a < _b.length; _a++) {
                     var member = _b[_a];
                     // only emit members in the correct group
-                    if ((member.flags & 128 /* Static */) !== staticFlag) {
+                    if ((member.flags & 64 /* Static */) !== staticFlag) {
                         continue;
                     }
                     // skip members that cannot be decorated (such as the constructor)
@@ -34580,7 +35023,7 @@ var ts;
                 }
                 if (!shouldHoistDeclarationInSystemJsModule(node)) {
                     // do not emit var if variable was already hoisted
-                    if (!(node.flags & 1 /* Export */) || isES6ExportedDeclaration(node)) {
+                    if (!(node.flags & 2 /* Export */) || isES6ExportedDeclaration(node)) {
                         emitStart(node);
                         if (isES6ExportedDeclaration(node)) {
                             write("export ");
@@ -34611,7 +35054,7 @@ var ts;
                 emitModuleMemberName(node);
                 write(" = {}));");
                 emitEnd(node);
-                if (!isES6ExportedDeclaration(node) && node.flags & 1 /* Export */ && !shouldHoistDeclarationInSystemJsModule(node)) {
+                if (!isES6ExportedDeclaration(node) && node.flags & 2 /* Export */ && !shouldHoistDeclarationInSystemJsModule(node)) {
                     // do not emit var if variable was already hoisted
                     writeLine();
                     emitStart(node);
@@ -34623,7 +35066,7 @@ var ts;
                     write(";");
                 }
                 if (modulekind !== 5 /* ES6 */ && node.parent === currentSourceFile) {
-                    if (modulekind === 4 /* System */ && (node.flags & 1 /* Export */)) {
+                    if (modulekind === 4 /* System */ && (node.flags & 2 /* Export */)) {
                         // write the call to exporter for enum
                         writeLine();
                         write(exportFunctionForFile + "(\"");
@@ -34728,7 +35171,7 @@ var ts;
                 }
                 write(")(");
                 // write moduleDecl = containingModule.m only if it is not exported es6 module member
-                if ((node.flags & 1 /* Export */) && !isES6ExportedDeclaration(node)) {
+                if ((node.flags & 2 /* Export */) && !isES6ExportedDeclaration(node)) {
                     emit(node.name);
                     write(" = ");
                 }
@@ -34738,7 +35181,7 @@ var ts;
                 write(" = {}));");
                 emitEnd(node);
                 if (!isES6ExportedDeclaration(node) && node.name.kind === 69 /* Identifier */ && node.parent === currentSourceFile) {
-                    if (modulekind === 4 /* System */ && (node.flags & 1 /* Export */)) {
+                    if (modulekind === 4 /* System */ && (node.flags & 2 /* Export */)) {
                         writeLine();
                         write(exportFunctionForFile + "(\"");
                         emitDeclarationName(node);
@@ -34841,7 +35284,7 @@ var ts;
             }
             function emitExternalImportDeclaration(node) {
                 if (ts.contains(externalImports, node)) {
-                    var isExportedImport = node.kind === 221 /* ImportEqualsDeclaration */ && (node.flags & 1 /* Export */) !== 0;
+                    var isExportedImport = node.kind === 221 /* ImportEqualsDeclaration */ && (node.flags & 2 /* Export */) !== 0;
                     var namespaceDeclaration = getNamespaceDeclarationNode(node);
                     if (modulekind !== 2 /* AMD */) {
                         emitLeadingComments(node);
@@ -34923,7 +35366,7 @@ var ts;
                             write("export ");
                             write("var ");
                         }
-                        else if (!(node.flags & 1 /* Export */)) {
+                        else if (!(node.flags & 2 /* Export */)) {
                             write("var ");
                         }
                     }
@@ -35014,8 +35457,8 @@ var ts;
             function emitExportOrImportSpecifierList(specifiers, shouldEmit) {
                 ts.Debug.assert(modulekind === 5 /* ES6 */);
                 var needsComma = false;
-                for (var _a = 0; _a < specifiers.length; _a++) {
-                    var specifier = specifiers[_a];
+                for (var _a = 0, specifiers_1 = specifiers; _a < specifiers_1.length; _a++) {
+                    var specifier = specifiers_1[_a];
                     if (shouldEmit(specifier)) {
                         if (needsComma) {
                             write(", ");
@@ -35158,8 +35601,8 @@ var ts;
                 }
                 writeLine();
                 var started = false;
-                for (var _a = 0; _a < externalImports.length; _a++) {
-                    var importNode = externalImports[_a];
+                for (var _a = 0, externalImports_1 = externalImports; _a < externalImports_1.length; _a++) {
+                    var importNode = externalImports_1[_a];
                     // do not create variable declaration for exports and imports that lack import clause
                     var skipNode = importNode.kind === 228 /* ExportDeclaration */ ||
                         (importNode.kind === 222 /* ImportDeclaration */ && !importNode.importClause);
@@ -35193,8 +35636,8 @@ var ts;
                     // no exported declarations (export var ...) or export specifiers (export {x})
                     // check if we have any non star export declarations.
                     var hasExportDeclarationWithExportClause = false;
-                    for (var _a = 0; _a < externalImports.length; _a++) {
-                        var externalImport = externalImports[_a];
+                    for (var _a = 0, externalImports_2 = externalImports; _a < externalImports_2.length; _a++) {
+                        var externalImport = externalImports_2[_a];
                         if (externalImport.kind === 228 /* ExportDeclaration */ && externalImport.exportClause) {
                             hasExportDeclarationWithExportClause = true;
                             break;
@@ -35225,8 +35668,8 @@ var ts;
                         }
                     }
                 }
-                for (var _d = 0; _d < externalImports.length; _d++) {
-                    var externalImport = externalImports[_d];
+                for (var _d = 0, externalImports_3 = externalImports; _d < externalImports_3.length; _d++) {
+                    var externalImport = externalImports_3[_d];
                     if (externalImport.kind !== 228 /* ExportDeclaration */) {
                         continue;
                     }
@@ -35275,7 +35718,7 @@ var ts;
                 function writeExportedName(node) {
                     // do not record default exports
                     // they are local to module and never overwritten (explicitly skipped) by star export
-                    if (node.kind !== 69 /* Identifier */ && node.flags & 1024 /* Default */) {
+                    if (node.kind !== 69 /* Identifier */ && node.flags & 512 /* Default */) {
                         return;
                     }
                     if (started) {
@@ -35338,7 +35781,7 @@ var ts;
                             emit(local);
                         }
                         var flags = ts.getCombinedNodeFlags(local.kind === 69 /* Identifier */ ? local.parent : local);
-                        if (flags & 1 /* Export */) {
+                        if (flags & 2 /* Export */) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -35348,11 +35791,11 @@ var ts;
                     write(";");
                 }
                 if (hoistedFunctionDeclarations) {
-                    for (var _a = 0; _a < hoistedFunctionDeclarations.length; _a++) {
-                        var f = hoistedFunctionDeclarations[_a];
+                    for (var _a = 0, hoistedFunctionDeclarations_1 = hoistedFunctionDeclarations; _a < hoistedFunctionDeclarations_1.length; _a++) {
+                        var f = hoistedFunctionDeclarations_1[_a];
                         writeLine();
                         emit(f);
-                        if (f.flags & 1 /* Export */) {
+                        if (f.flags & 2 /* Export */) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
                             }
@@ -35362,7 +35805,7 @@ var ts;
                 }
                 return exportedDeclarations;
                 function visit(node) {
-                    if (node.flags & 2 /* Ambient */) {
+                    if (node.flags & 4 /* Ambient */) {
                         return;
                     }
                     if (node.kind === 213 /* FunctionDeclaration */) {
@@ -35437,7 +35880,7 @@ var ts;
                 // - it is top level block scoped
                 // if block scoped variables are nested in some another block then
                 // no other functions can use them except ones that are defined at least in the same block
-                return (ts.getCombinedNodeFlags(node) & 49152 /* BlockScoped */) === 0 ||
+                return (ts.getCombinedNodeFlags(node) & 24576 /* BlockScoped */) === 0 ||
                     ts.getEnclosingBlockScopeContainer(node).kind === 248 /* SourceFile */;
             }
             function isCurrentFileSystemExternalModule() {
@@ -35509,8 +35952,8 @@ var ts;
                     var parameterName = makeUniqueName(ts.forEach(group, getLocalNameForExternalImport) || "");
                     write("function (" + parameterName + ") {");
                     increaseIndent();
-                    for (var _a = 0; _a < group.length; _a++) {
-                        var entry = group[_a];
+                    for (var _a = 0, group_1 = group; _a < group_1.length; _a++) {
+                        var entry = group_1[_a];
                         var importVariableName = getLocalNameForExternalImport(entry) || "";
                         switch (entry.kind) {
                             case 222 /* ImportDeclaration */:
@@ -35679,8 +36122,8 @@ var ts;
                         unaliasedModuleNames.push("\"" + amdDependency.path + "\"");
                     }
                 }
-                for (var _c = 0; _c < externalImports.length; _c++) {
-                    var importNode = externalImports[_c];
+                for (var _c = 0, externalImports_4 = externalImports; _c < externalImports_4.length; _c++) {
+                    var importNode = externalImports_4[_c];
                     // Find the name of the external module
                     var externalModuleName = getExternalModuleNameText(importNode);
                     // Find the name of the module alias, if there is one
@@ -35959,7 +36402,7 @@ var ts;
                 // Start new file on new line
                 writeLine();
                 emitShebang();
-                emitDetachedComments(node);
+                emitDetachedCommentsAndUpdateCommentsInfo(node);
                 if (ts.isExternalModule(node) || compilerOptions.isolatedModules) {
                     var emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[1 /* CommonJS */];
                     emitModule(node);
@@ -35983,7 +36426,7 @@ var ts;
             }
             function emitNodeConsideringCommentsOption(node, emitNodeConsideringSourcemap) {
                 if (node) {
-                    if (node.flags & 2 /* Ambient */) {
+                    if (node.flags & 4 /* Ambient */) {
                         return emitCommentsOnNotEmittedNode(node);
                     }
                     if (isSpecializedCommentHandling(node)) {
@@ -36232,10 +36675,6 @@ var ts;
                 }
                 return leadingComments;
             }
-            function isPinnedComments(comment) {
-                return currentSourceFile.text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
-                    currentSourceFile.text.charCodeAt(comment.pos + 2) === 33 /* exclamation */;
-            }
             /**
              * Determine if the given comment is a triple-slash
              *
@@ -36350,57 +36789,14 @@ var ts;
                 // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
                 ts.emitComments(currentSourceFile, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
             }
-            function emitDetachedComments(node) {
-                var leadingComments;
-                if (compilerOptions.removeComments) {
-                    // removeComments is true, only reserve pinned comment at the top of file
-                    // For example:
-                    //      /*! Pinned Comment */
-                    //
-                    //      var x = 10;
-                    if (node.pos === 0) {
-                        leadingComments = ts.filter(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComments);
+            function emitDetachedCommentsAndUpdateCommentsInfo(node) {
+                var currentDetachedCommentInfo = ts.emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, compilerOptions.removeComments);
+                if (currentDetachedCommentInfo) {
+                    if (detachedCommentsInfo) {
+                        detachedCommentsInfo.push(currentDetachedCommentInfo);
                     }
-                }
-                else {
-                    // removeComments is false, just get detached as normal and bypass the process to filter comment
-                    leadingComments = ts.getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                }
-                if (leadingComments) {
-                    var detachedComments = [];
-                    var lastComment;
-                    ts.forEach(leadingComments, function (comment) {
-                        if (lastComment) {
-                            var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, lastComment.end);
-                            var commentLine = ts.getLineOfLocalPosition(currentSourceFile, comment.pos);
-                            if (commentLine >= lastCommentLine + 2) {
-                                // There was a blank line between the last comment and this comment.  This
-                                // comment is not part of the copyright comments.  Return what we have so
-                                // far.
-                                return detachedComments;
-                            }
-                        }
-                        detachedComments.push(comment);
-                        lastComment = comment;
-                    });
-                    if (detachedComments.length) {
-                        // All comments look like they could have been part of the copyright header.  Make
-                        // sure there is at least one blank line between it and the node.  If not, it's not
-                        // a copyright header.
-                        var lastCommentLine = ts.getLineOfLocalPosition(currentSourceFile, ts.lastOrUndefined(detachedComments).end);
-                        var nodeLine = ts.getLineOfLocalPosition(currentSourceFile, ts.skipTrivia(currentSourceFile.text, node.pos));
-                        if (nodeLine >= lastCommentLine + 2) {
-                            // Valid detachedComments
-                            ts.emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
-                            ts.emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
-                            var currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
-                            if (detachedCommentsInfo) {
-                                detachedCommentsInfo.push(currentDetachedCommentInfo);
-                            }
-                            else {
-                                detachedCommentsInfo = [currentDetachedCommentInfo];
-                            }
-                        }
+                    else {
+                        detachedCommentsInfo = [currentDetachedCommentInfo];
                     }
                 }
             }
@@ -36716,7 +37112,7 @@ var ts;
         var resolveModuleNamesWorker = host.resolveModuleNames
             ? (function (moduleNames, containingFile) { return host.resolveModuleNames(moduleNames, containingFile); })
             : (function (moduleNames, containingFile) { return ts.map(moduleNames, function (moduleName) { return resolveModuleName(moduleName, containingFile, options, host).resolvedModule; }); });
-        var filesByName = ts.createFileMap(getCanonicalFileName);
+        var filesByName = ts.createFileMap();
         // stores 'filename -> file association' ignoring case
         // used to track cases when two file names differ only in casing 
         var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? ts.createFileMap(function (fileName) { return fileName.toLowerCase(); }) : undefined;
@@ -36774,8 +37170,8 @@ var ts;
                 // Initialize a checker so that all our files are bound.
                 getTypeChecker();
                 classifiableNames = {};
-                for (var _i = 0; _i < files.length; _i++) {
-                    var sourceFile = files[_i];
+                for (var _i = 0, files_3 = files; _i < files_3.length; _i++) {
+                    var sourceFile = files_3[_i];
                     ts.copyMap(sourceFile.classifiableNames, classifiableNames);
                 }
             }
@@ -36793,7 +37189,7 @@ var ts;
             }
             // check if program source files has changed in the way that can affect structure of the program
             var newSourceFiles = [];
-            var normalizedAbsoluteFileNames = [];
+            var filePaths = [];
             var modifiedSourceFiles = [];
             for (var _i = 0, _a = oldProgram.getSourceFiles(); _i < _a.length; _i++) {
                 var oldSourceFile = _a[_i];
@@ -36801,8 +37197,8 @@ var ts;
                 if (!newSourceFile) {
                     return false;
                 }
-                var normalizedAbsolutePath = ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory);
-                normalizedAbsoluteFileNames.push(normalizedAbsolutePath);
+                newSourceFile.path = oldSourceFile.path;
+                filePaths.push(newSourceFile.path);
                 if (oldSourceFile !== newSourceFile) {
                     if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
                         // value of no-default-lib has changed
@@ -36822,7 +37218,7 @@ var ts;
                     }
                     if (resolveModuleNamesWorker) {
                         var moduleNames = ts.map(newSourceFile.imports, function (name) { return name.text; });
-                        var resolutions = resolveModuleNamesWorker(moduleNames, normalizedAbsolutePath);
+                        var resolutions = resolveModuleNamesWorker(moduleNames, ts.getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));
                         // ensure that module resolution results are still correct
                         for (var i = 0; i < moduleNames.length; ++i) {
                             var newResolution = resolutions[i];
@@ -36850,12 +37246,12 @@ var ts;
             }
             // update fileName -> file mapping
             for (var i = 0, len = newSourceFiles.length; i < len; ++i) {
-                filesByName.set(normalizedAbsoluteFileNames[i], newSourceFiles[i]);
+                filesByName.set(filePaths[i], newSourceFiles[i]);
             }
             files = newSourceFiles;
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
-            for (var _b = 0; _b < modifiedSourceFiles.length; _b++) {
-                var modifiedFile = modifiedSourceFiles[_b];
+            for (var _b = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _b < modifiedSourceFiles_1.length; _b++) {
+                var modifiedFile = modifiedSourceFiles_1[_b];
                 fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);
             }
             oldProgram.structureIsReused = true;
@@ -36905,7 +37301,7 @@ var ts;
             return emitResult;
         }
         function getSourceFile(fileName) {
-            return filesByName.get(ts.getNormalizedAbsolutePath(fileName, currentDirectory));
+            return filesByName.get(ts.toPath(fileName, currentDirectory, getCanonicalFileName));
         }
         function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) {
             if (sourceFile) {
@@ -37024,7 +37420,7 @@ var ts;
                         }
                         break;
                     case 218 /* ModuleDeclaration */:
-                        if (node.name.kind === 9 /* StringLiteral */ && (node.flags & 2 /* Ambient */ || ts.isDeclarationFile(file))) {
+                        if (node.name.kind === 9 /* StringLiteral */ && (node.flags & 4 /* Ambient */ || ts.isDeclarationFile(file))) {
                             // TypeScript 1.0 spec (April 2014): 12.1.6
                             // An AmbientExternalModuleDeclaration declares an external module. 
                             // This type of declaration is permitted only in the global module.
@@ -37049,7 +37445,7 @@ var ts;
                     diagnostic = ts.Diagnostics.File_0_has_unsupported_extension_The_only_supported_extensions_are_1;
                     diagnosticArgument = [fileName, "'" + ts.supportedExtensions.join("', '") + "'"];
                 }
-                else if (!findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd)) {
+                else if (!findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd)) {
                     diagnostic = ts.Diagnostics.File_0_not_found;
                     diagnosticArgument = [fileName];
                 }
@@ -37059,13 +37455,13 @@ var ts;
                 }
             }
             else {
-                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.getNormalizedAbsolutePath(fileName, currentDirectory), isDefaultLib, refFile, refPos, refEnd);
+                var nonTsFile = options.allowNonTsExtensions && findSourceFile(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd);
                 if (!nonTsFile) {
                     if (options.allowNonTsExtensions) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         diagnosticArgument = [fileName];
                     }
-                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.getNormalizedAbsolutePath(fileName + extension, currentDirectory), isDefaultLib, refFile, refPos, refEnd); })) {
+                    else if (!ts.forEach(ts.supportedExtensions, function (extension) { return findSourceFile(fileName + extension, ts.toPath(fileName + extension, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd); })) {
                         diagnostic = ts.Diagnostics.File_0_not_found;
                         fileName += ".ts";
                         diagnosticArgument = [fileName];
@@ -37111,6 +37507,7 @@ var ts;
             });
             filesByName.set(normalizedAbsolutePath, file);
             if (file) {
+                file.path = normalizedAbsolutePath;
                 if (host.useCaseSensitiveFileNames()) {
                     // for case-sensitive file systems check if we've already seen some file with similar filename ignoring case
                     var existingFile = filesByNameIgnoreCase.get(normalizedAbsolutePath);
@@ -37157,13 +37554,7 @@ var ts;
                     var resolution = resolutions[i];
                     ts.setResolvedModule(file, moduleNames[i], resolution);
                     if (resolution && !options.noResolve) {
-                        var absoluteImportPath = ts.isRootedDiskPath(resolution.resolvedFileName)
-                            ? resolution.resolvedFileName
-                            : ts.getNormalizedAbsolutePath(resolution.resolvedFileName, currentDirectory);
-                        // convert an absolute import path to path that is relative to current directory
-                        // this was host still can locate it but files names in user output will be shorter (and thus look nicer).
-                        var relativePath = ts.getRelativePathToDirectoryOrUrl(currentDirectory, absoluteImportPath, currentDirectory, getCanonicalFileName, false);
-                        var importedFile = findSourceFile(relativePath, absoluteImportPath, /* isDefaultLib */ false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
+                        var importedFile = findSourceFile(resolution.resolvedFileName, ts.toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), /* isDefaultLib */ false, file, ts.skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!ts.isExternalModule(importedFile)) {
                                 var start_2 = ts.getTokenPosOfNode(file.imports[i], file);
@@ -37219,8 +37610,8 @@ var ts;
             var allFilesBelongToPath = true;
             if (sourceFiles) {
                 var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) {
+                    var sourceFile = sourceFiles_1[_i];
                     if (!ts.isDeclarationFile(sourceFile)) {
                         var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
                         if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
@@ -37344,6 +37735,7 @@ var ts;
 /// <reference path="sys.ts"/>
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
+/// <reference path="diagnosticInformationMap.generated.ts"/>
 /// <reference path="scanner.ts"/>
 var ts;
 (function (ts) {
@@ -37493,6 +37885,12 @@ var ts;
             type: "boolean",
             description: ts.Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
         },
+        {
+            name: "pretty",
+            paramType: ts.Diagnostics.KIND,
+            description: ts.Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
         {
             name: "project",
             shortName: "p",
@@ -37591,11 +37989,31 @@ var ts;
             description: ts.Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
             error: ts.Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic
         },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: ts.Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: ts.Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: ts.Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
         {
             name: "forceConsistentCasingInFileNames",
             type: "boolean",
             description: ts.Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
-        },
+        }
     ];
     var optionNameMapCache;
     /* @internal */
@@ -37734,13 +38152,38 @@ var ts;
       */
     function parseConfigFileTextToJson(fileName, jsonText) {
         try {
-            return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
+            var jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
         }
         catch (e) {
             return { error: ts.createCompilerDiagnostic(ts.Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
         }
     }
     ts.parseConfigFileTextToJson = parseConfigFileTextToJson;
+    /**
+     * Remove the comments from a json like text.
+     * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
+     *
+     * This method replace comment content by whitespace rather than completely remove them to keep positions in json parsing error reporting accurate.
+     */
+    function removeComments(jsonText) {
+        var output = "";
+        var scanner = ts.createScanner(1 /* ES5 */, /* skipTrivia */ false, 0 /* Standard */, jsonText);
+        var token;
+        while ((token = scanner.scan()) !== 1 /* EndOfFileToken */) {
+            switch (token) {
+                case 2 /* SingleLineCommentTrivia */:
+                case 3 /* MultiLineCommentTrivia */:
+                    // replace comments with whitespace to preserve original character positions
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
     /**
       * Parse the contents of a config file (tsconfig.json).
       * @param json The contents of the config file to parse
@@ -37871,8 +38314,8 @@ var ts;
                     var lastSingleLineCommentEnd = -1;
                     var isFirstSingleLineComment = true;
                     var singleLineCommentCount = 0;
-                    for (var _i = 0; _i < comments.length; _i++) {
-                        var currentComment = comments[_i];
+                    for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) {
+                        var currentComment = comments_2[_i];
                         // For single line comments, combine consecutive ones (2 or more) into
                         // a single span from the start of the first till the end of the last
                         if (currentComment.kind === 2 /* SingleLineCommentTrivia */) {
@@ -38004,6 +38447,8 @@ var ts;
         function getNavigateToItems(program, cancellationToken, searchValue, maxResultCount) {
             var patternMatcher = ts.createPatternMatcher(searchValue);
             var rawItems = [];
+            // This means "compare in a case insensitive manner."
+            var baseSensitivity = { sensitivity: "base" };
             // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] 
             ts.forEach(program.getSourceFiles(), function (sourceFile) {
                 cancellationToken.throwIfCancellationRequested();
@@ -38017,8 +38462,8 @@ var ts;
                         if (!matches) {
                             continue;
                         }
-                        for (var _i = 0; _i < declarations.length; _i++) {
-                            var declaration = declarations[_i];
+                        for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
+                            var declaration = declarations_6[_i];
                             // It was a match!  If the pattern has dots in it, then also see if the 
                             // declaration container matches as well.
                             if (patternMatcher.patternContainsDots) {
@@ -38047,8 +38492,8 @@ var ts;
             function allMatchesAreCaseSensitive(matches) {
                 ts.Debug.assert(matches.length > 0);
                 // This is a case sensitive match, only if all the submatches were case sensitive.
-                for (var _i = 0; _i < matches.length; _i++) {
-                    var match = matches[_i];
+                for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
+                    var match = matches_1[_i];
                     if (!match.isCaseSensitive) {
                         return false;
                     }
@@ -38123,8 +38568,8 @@ var ts;
             function bestMatchKind(matches) {
                 ts.Debug.assert(matches.length > 0);
                 var bestMatchKind = ts.PatternMatchKind.camelCase;
-                for (var _i = 0; _i < matches.length; _i++) {
-                    var match = matches[_i];
+                for (var _i = 0, matches_2 = matches; _i < matches_2.length; _i++) {
+                    var match = matches_2[_i];
                     var kind = match.kind;
                     if (kind < bestMatchKind) {
                         bestMatchKind = kind;
@@ -38132,8 +38577,6 @@ var ts;
                 }
                 return bestMatchKind;
             }
-            // This means "compare in a case insensitive manner."
-            var baseSensitivity = { sensitivity: "base" };
             function compareNavigateToItems(i1, i2) {
                 // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
                 // Right now we just sort by kind first, and then by name of the item.
@@ -38296,8 +38739,8 @@ var ts;
             }
             function addTopLevelNodes(nodes, topLevelNodes) {
                 nodes = sortNodes(nodes);
-                for (var _i = 0; _i < nodes.length; _i++) {
-                    var node = nodes[_i];
+                for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) {
+                    var node = nodes_4[_i];
                     switch (node.kind) {
                         case 214 /* ClassDeclaration */:
                         case 217 /* EnumDeclaration */:
@@ -38340,8 +38783,8 @@ var ts;
             function getItemsWorker(nodes, createItem) {
                 var items = [];
                 var keyToItem = {};
-                for (var _i = 0; _i < nodes.length; _i++) {
-                    var child = nodes[_i];
+                for (var _i = 0, nodes_5 = nodes; _i < nodes_5.length; _i++) {
+                    var child = nodes_5[_i];
                     var item = createItem(child);
                     if (item !== undefined) {
                         if (item.text.length > 0) {
@@ -38389,7 +38832,7 @@ var ts;
                         if (ts.isBindingPattern(node.name)) {
                             break;
                         }
-                        if ((node.flags & 2035 /* Modifier */) === 0) {
+                        if ((node.flags & 1022 /* Modifier */) === 0) {
                             return undefined;
                         }
                         return createItem(node, getTextOfNode(node.name), ts.ScriptElementKind.memberVariableElement);
@@ -38693,8 +39136,8 @@ var ts;
                     //    word part. That way we don't match something like 'Class' when the user types 'a'.
                     //    But we would match 'FooAttribute' (since 'Attribute' starts with 'a').
                     var wordSpans = getWordSpans(candidate);
-                    for (var _i = 0; _i < wordSpans.length; _i++) {
-                        var span = wordSpans[_i];
+                    for (var _i = 0, wordSpans_1 = wordSpans; _i < wordSpans_1.length; _i++) {
+                        var span = wordSpans_1[_i];
                         if (partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ true)) {
                             return createPatternMatch(PatternMatchKind.substring, punctuationStripped, 
                             /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ false));
@@ -38800,8 +39243,8 @@ var ts;
             // Only if all words have some sort of match is the pattern considered matched.
             var subWordTextChunks = segment.subWordTextChunks;
             var matches = undefined;
-            for (var _i = 0; _i < subWordTextChunks.length; _i++) {
-                var subWordTextChunk = subWordTextChunks[_i];
+            for (var _i = 0, subWordTextChunks_1 = subWordTextChunks; _i < subWordTextChunks_1.length; _i++) {
+                var subWordTextChunk = subWordTextChunks_1[_i];
                 // Try to match the candidate with this word
                 var result = matchTextChunk(candidate, subWordTextChunk, /*punctuationStripped:*/ true);
                 if (!result) {
@@ -39386,8 +39829,8 @@ var ts;
                     var nameToDeclarations = sourceFile_1.getNamedDeclarations();
                     var declarations = ts.getProperty(nameToDeclarations, name.text);
                     if (declarations) {
-                        for (var _b = 0; _b < declarations.length; _b++) {
-                            var declaration = declarations[_b];
+                        for (var _b = 0, declarations_7 = declarations; _b < declarations_7.length; _b++) {
+                            var declaration = declarations_7[_b];
                             var symbol = declaration.symbol;
                             if (symbol) {
                                 var type = typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
@@ -39503,8 +39946,8 @@ var ts;
                 // arg index.
                 var argumentIndex = 0;
                 var listChildren = argumentsList.getChildren();
-                for (var _i = 0; _i < listChildren.length; _i++) {
-                    var child = listChildren[_i];
+                for (var _i = 0, listChildren_1 = listChildren; _i < listChildren_1.length; _i++) {
+                    var child = listChildren_1[_i];
                     if (child === node) {
                         break;
                     }
@@ -40049,8 +40492,8 @@ var ts;
                 return n;
             }
             var children = n.getChildren();
-            for (var _i = 0; _i < children.length; _i++) {
-                var child = children[_i];
+            for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+                var child = children_1[_i];
                 var shouldDiveInChildNode = 
                 // previous token is enclosed somewhere in the child
                 (child.pos <= previousToken.pos && child.end > previousToken.end) ||
@@ -40212,17 +40655,17 @@ var ts;
     function getNodeModifiers(node) {
         var flags = ts.getCombinedNodeFlags(node);
         var result = [];
-        if (flags & 32 /* Private */)
+        if (flags & 16 /* Private */)
             result.push(ts.ScriptElementKindModifier.privateMemberModifier);
-        if (flags & 64 /* Protected */)
+        if (flags & 32 /* Protected */)
             result.push(ts.ScriptElementKindModifier.protectedMemberModifier);
-        if (flags & 16 /* Public */)
+        if (flags & 8 /* Public */)
             result.push(ts.ScriptElementKindModifier.publicMemberModifier);
-        if (flags & 128 /* Static */)
+        if (flags & 64 /* Static */)
             result.push(ts.ScriptElementKindModifier.staticModifier);
-        if (flags & 256 /* Abstract */)
+        if (flags & 128 /* Abstract */)
             result.push(ts.ScriptElementKindModifier.abstractModifier);
-        if (flags & 1 /* Export */)
+        if (flags & 2 /* Export */)
             result.push(ts.ScriptElementKindModifier.exportedModifier);
         if (ts.isInAmbientContext(node))
             result.push(ts.ScriptElementKindModifier.ambientModifier);
@@ -42366,8 +42809,8 @@ var ts;
                         }
                     }
                     var inheritedIndentation = -1 /* Unknown */;
-                    for (var _i = 0; _i < nodes.length; _i++) {
-                        var child = nodes[_i];
+                    for (var _i = 0, nodes_6 = nodes; _i < nodes_6.length; _i++) {
+                        var child = nodes_6[_i];
                         inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, /*isListElement*/ true);
                     }
                     if (listEndToken !== 0 /* Unknown */) {
@@ -42458,8 +42901,8 @@ var ts;
                 }
             }
             function processTrivia(trivia, parent, contextNode, dynamicIndentation) {
-                for (var _i = 0; _i < trivia.length; _i++) {
-                    var triviaItem = trivia[_i];
+                for (var _i = 0, trivia_1 = trivia; _i < trivia_1.length; _i++) {
+                    var triviaItem = trivia_1[_i];
                     if (ts.isComment(triviaItem.kind) && ts.rangeContainsRange(originalRange, triviaItem)) {
                         var triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos);
                         processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation);
@@ -43056,7 +43499,6 @@ var ts;
                                 return node;
                         }
                     }
-                    return node;
                 }
             }
             function deriveActualIndentationFromList(list, index, sourceFile, options) {
@@ -43307,17 +43749,17 @@ var ts;
             while (pos < end) {
                 var token = scanner.scan();
                 var textPos = scanner.getTextPos();
-                nodes.push(createNode(token, pos, textPos, 4096 /* Synthetic */, this));
+                nodes.push(createNode(token, pos, textPos, 2048 /* Synthetic */, this));
                 pos = textPos;
             }
             return pos;
         };
         NodeObject.prototype.createSyntaxList = function (nodes) {
-            var list = createNode(271 /* SyntaxList */, nodes.pos, nodes.end, 4096 /* Synthetic */, this);
+            var list = createNode(271 /* SyntaxList */, nodes.pos, nodes.end, 2048 /* Synthetic */, this);
             list._children = [];
             var pos = nodes.pos;
-            for (var _i = 0; _i < nodes.length; _i++) {
-                var node = nodes[_i];
+            for (var _i = 0, nodes_7 = nodes; _i < nodes_7.length; _i++) {
+                var node = nodes_7[_i];
                 if (pos < node.pos) {
                     pos = this.addSyntheticNodes(list._children, pos, node.pos);
                 }
@@ -43872,7 +44314,7 @@ var ts;
                         break;
                     case 138 /* Parameter */:
                         // Only consider properties defined as constructor parameters
-                        if (!(node.flags & 112 /* AccessibilityModifier */)) {
+                        if (!(node.flags & 56 /* AccessibilityModifier */)) {
                             break;
                         }
                     // fall through
@@ -44148,13 +44590,15 @@ var ts;
     var HostCache = (function () {
         function HostCache(host, getCanonicalFileName) {
             this.host = host;
+            this.getCanonicalFileName = getCanonicalFileName;
             // script id => script index
-            this.fileNameToEntry = ts.createFileMap(getCanonicalFileName);
+            this.currentDirectory = host.getCurrentDirectory();
+            this.fileNameToEntry = ts.createFileMap();
             // Initialize the list with the root file names
             var rootFileNames = host.getScriptFileNames();
-            for (var _i = 0; _i < rootFileNames.length; _i++) {
-                var fileName = rootFileNames[_i];
-                this.createEntry(fileName);
+            for (var _i = 0, rootFileNames_1 = rootFileNames; _i < rootFileNames_1.length; _i++) {
+                var fileName = rootFileNames_1[_i];
+                this.createEntry(fileName, ts.toPath(fileName, this.currentDirectory, getCanonicalFileName));
             }
             // store the compilation settings
             this._compilationSettings = host.getCompilationSettings() || getDefaultCompilerOptions();
@@ -44162,7 +44606,7 @@ var ts;
         HostCache.prototype.compilationSettings = function () {
             return this._compilationSettings;
         };
-        HostCache.prototype.createEntry = function (fileName) {
+        HostCache.prototype.createEntry = function (fileName, path) {
             var entry;
             var scriptSnapshot = this.host.getScriptSnapshot(fileName);
             if (scriptSnapshot) {
@@ -44172,36 +44616,37 @@ var ts;
                     scriptSnapshot: scriptSnapshot
                 };
             }
-            this.fileNameToEntry.set(fileName, entry);
+            this.fileNameToEntry.set(path, entry);
             return entry;
         };
-        HostCache.prototype.getEntry = function (fileName) {
-            return this.fileNameToEntry.get(fileName);
+        HostCache.prototype.getEntry = function (path) {
+            return this.fileNameToEntry.get(path);
         };
-        HostCache.prototype.contains = function (fileName) {
-            return this.fileNameToEntry.contains(fileName);
+        HostCache.prototype.contains = function (path) {
+            return this.fileNameToEntry.contains(path);
         };
         HostCache.prototype.getOrCreateEntry = function (fileName) {
-            if (this.contains(fileName)) {
-                return this.getEntry(fileName);
+            var path = ts.toPath(fileName, this.currentDirectory, this.getCanonicalFileName);
+            if (this.contains(path)) {
+                return this.getEntry(path);
             }
-            return this.createEntry(fileName);
+            return this.createEntry(fileName, path);
         };
         HostCache.prototype.getRootFileNames = function () {
             var fileNames = [];
-            this.fileNameToEntry.forEachValue(function (value) {
+            this.fileNameToEntry.forEachValue(function (path, value) {
                 if (value) {
                     fileNames.push(value.hostFileName);
                 }
             });
             return fileNames;
         };
-        HostCache.prototype.getVersion = function (fileName) {
-            var file = this.getEntry(fileName);
+        HostCache.prototype.getVersion = function (path) {
+            var file = this.getEntry(path);
             return file && file.version;
         };
-        HostCache.prototype.getScriptSnapshot = function (fileName) {
-            var file = this.getEntry(fileName);
+        HostCache.prototype.getScriptSnapshot = function (path) {
+            var file = this.getEntry(path);
             return file && file.scriptSnapshot;
         };
         return HostCache;
@@ -44383,7 +44828,8 @@ var ts;
             : (function (fileName) { return fileName.toLowerCase(); });
     }
     ts.createGetCanonicalFileName = createGetCanonicalFileName;
-    function createDocumentRegistry(useCaseSensitiveFileNames) {
+    function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) {
+        if (currentDirectory === void 0) { currentDirectory = ""; }
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.
         var buckets = {};
@@ -44395,7 +44841,7 @@ var ts;
             var key = getKeyFromCompilationSettings(settings);
             var bucket = ts.lookUp(buckets, key);
             if (!bucket && createIfMissing) {
-                buckets[key] = bucket = ts.createFileMap(getCanonicalFileName);
+                buckets[key] = bucket = ts.createFileMap();
             }
             return bucket;
         }
@@ -44403,14 +44849,13 @@ var ts;
             var bucketInfoArray = Object.keys(buckets).filter(function (name) { return name && name.charAt(0) === '_'; }).map(function (name) {
                 var entries = ts.lookUp(buckets, name);
                 var sourceFiles = [];
-                for (var i in entries) {
-                    var entry = entries.get(i);
+                entries.forEachValue(function (key, entry) {
                     sourceFiles.push({
-                        name: i,
+                        name: key,
                         refCount: entry.languageServiceRefCount,
                         references: entry.owners.slice(0)
                     });
-                }
+                });
                 sourceFiles.sort(function (x, y) { return y.refCount - x.refCount; });
                 return {
                     bucket: name,
@@ -44427,7 +44872,8 @@ var ts;
         }
         function acquireOrUpdateDocument(fileName, compilationSettings, scriptSnapshot, version, acquiring) {
             var bucket = getBucketForCompilationSettings(compilationSettings, /*createIfMissing*/ true);
-            var entry = bucket.get(fileName);
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var entry = bucket.get(path);
             if (!entry) {
                 ts.Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?");
                 // Have never seen this file with these settings.  Create a new source file for it.
@@ -44437,7 +44883,7 @@ var ts;
                     languageServiceRefCount: 0,
                     owners: []
                 };
-                bucket.set(fileName, entry);
+                bucket.set(path, entry);
             }
             else {
                 // We have an entry for this file.  However, it may be for a different version of
@@ -44460,11 +44906,12 @@ var ts;
         function releaseDocument(fileName, compilationSettings) {
             var bucket = getBucketForCompilationSettings(compilationSettings, false);
             ts.Debug.assert(bucket !== undefined);
-            var entry = bucket.get(fileName);
+            var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+            var entry = bucket.get(path);
             entry.languageServiceRefCount--;
             ts.Debug.assert(entry.languageServiceRefCount >= 0);
             if (entry.languageServiceRefCount === 0) {
-                bucket.remove(fileName);
+                bucket.remove(path);
             }
         }
         return {
@@ -44871,7 +45318,7 @@ var ts;
             case 144 /* Constructor */: return ScriptElementKind.constructorImplementationElement;
             case 137 /* TypeParameter */: return ScriptElementKind.typeParameterElement;
             case 247 /* EnumMember */: return ScriptElementKind.variableElement;
-            case 138 /* Parameter */: return (node.flags & 112 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
+            case 138 /* Parameter */: return (node.flags & 56 /* AccessibilityModifier */) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
             case 221 /* ImportEqualsDeclaration */:
             case 226 /* ImportSpecifier */:
             case 223 /* ImportClause */:
@@ -44897,13 +45344,14 @@ var ts;
         return CancellationTokenObject;
     })();
     function createLanguageService(host, documentRegistry) {
-        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(); }
+        if (documentRegistry === void 0) { documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()); }
         var syntaxTreeCache = new SyntaxTreeCache(host);
         var ruleProvider;
         var program;
         var lastProjectVersion;
         var useCaseSensitivefileNames = false;
         var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
+        var currentDirectory = host.getCurrentDirectory();
         // Check if the localized messages json is set, otherwise query the host for it
         if (!ts.localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) {
             ts.localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages();
@@ -44915,8 +45363,7 @@ var ts;
         }
         var getCanonicalFileName = createGetCanonicalFileName(useCaseSensitivefileNames);
         function getValidSourceFile(fileName) {
-            fileName = ts.normalizeSlashes(fileName);
-            var sourceFile = program.getSourceFile(getCanonicalFileName(fileName));
+            var sourceFile = program.getSourceFile(fileName);
             if (!sourceFile) {
                 throw new Error("Could not find file: '" + fileName + "'.");
             }
@@ -44968,7 +45415,7 @@ var ts;
                 getNewLine: function () { return ts.getNewLineOrDefaultFromHost(host); },
                 getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); },
                 writeFile: function (fileName, data, writeByteOrderMark) { },
-                getCurrentDirectory: function () { return host.getCurrentDirectory(); },
+                getCurrentDirectory: function () { return currentDirectory; },
                 fileExists: function (fileName) {
                     // stub missing host functionality
                     ts.Debug.assert(!host.resolveModuleNames);
@@ -44988,11 +45435,10 @@ var ts;
             // not part of the new program.
             if (program) {
                 var oldSourceFiles = program.getSourceFiles();
-                for (var _i = 0; _i < oldSourceFiles.length; _i++) {
-                    var oldSourceFile = oldSourceFiles[_i];
-                    var fileName = oldSourceFile.fileName;
-                    if (!newProgram.getSourceFile(fileName) || changesInCompilationSettingsAffectSyntax) {
-                        documentRegistry.releaseDocument(fileName, oldSettings);
+                for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) {
+                    var oldSourceFile = oldSourceFiles_1[_i];
+                    if (!newProgram.getSourceFile(oldSourceFile.fileName) || changesInCompilationSettingsAffectSyntax) {
+                        documentRegistry.releaseDocument(oldSourceFile.fileName, oldSettings);
                     }
                 }
             }
@@ -45048,7 +45494,8 @@ var ts;
                 return documentRegistry.acquireDocument(fileName, newSettings, hostFileInformation.scriptSnapshot, hostFileInformation.version);
             }
             function sourceFileUpToDate(sourceFile) {
-                return sourceFile && sourceFile.version === hostCache.getVersion(sourceFile.fileName);
+                var path = sourceFile.path || ts.toPath(sourceFile.fileName, currentDirectory, getCanonicalFileName);
+                return sourceFile && sourceFile.version === hostCache.getVersion(path);
             }
             function programUpToDate() {
                 // If we haven't create a program yet, then it is not up-to-date
@@ -45061,8 +45508,8 @@ var ts;
                     return false;
                 }
                 // If any file is not up-to-date, then the whole program is not up-to-date
-                for (var _i = 0; _i < rootFileNames.length; _i++) {
-                    var fileName = rootFileNames[_i];
+                for (var _i = 0, rootFileNames_2 = rootFileNames; _i < rootFileNames_2.length; _i++) {
+                    var fileName = rootFileNames_2[_i];
                     if (!sourceFileUpToDate(program.getSourceFile(fileName))) {
                         return false;
                     }
@@ -45237,8 +45684,8 @@ var ts;
             }
             function checkModifiers(modifiers) {
                 if (modifiers) {
-                    for (var _i = 0; _i < modifiers.length; _i++) {
-                        var modifier = modifiers[_i];
+                    for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) {
+                        var modifier = modifiers_1[_i];
                         switch (modifier.kind) {
                             case 112 /* PublicKeyword */:
                             case 110 /* PrivateKeyword */:
@@ -45940,8 +46387,8 @@ var ts;
              */
             function filterNamedImportOrExportCompletionItems(exportsOfModule, namedImportsOrExports) {
                 var exisingImportsOrExports = {};
-                for (var _i = 0; _i < namedImportsOrExports.length; _i++) {
-                    var element = namedImportsOrExports[_i];
+                for (var _i = 0, namedImportsOrExports_1 = namedImportsOrExports; _i < namedImportsOrExports_1.length; _i++) {
+                    var element = namedImportsOrExports_1[_i];
                     // If this is the current item we are editing right now, do not filter it out
                     if (element.getStart() <= position && position <= element.getEnd()) {
                         continue;
@@ -45965,8 +46412,8 @@ var ts;
                     return contextualMemberSymbols;
                 }
                 var existingMemberNames = {};
-                for (var _i = 0; _i < existingMembers.length; _i++) {
-                    var m = existingMembers[_i];
+                for (var _i = 0, existingMembers_1 = existingMembers; _i < existingMembers_1.length; _i++) {
+                    var m = existingMembers_1[_i];
                     // Ignore omitted expressions for missing members
                     if (m.kind !== 245 /* PropertyAssignment */ &&
                         m.kind !== 246 /* ShorthandPropertyAssignment */ &&
@@ -45999,8 +46446,8 @@ var ts;
              */
             function filterJsxAttributes(symbols, attributes) {
                 var seenNames = {};
-                for (var _i = 0; _i < attributes.length; _i++) {
-                    var attr = attributes[_i];
+                for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
+                    var attr = attributes_1[_i];
                     // If this is the current item we are editing right now, do not filter it out
                     if (attr.getStart() <= position && position <= attr.getEnd()) {
                         continue;
@@ -46101,8 +46548,8 @@ var ts;
                 var entries = [];
                 if (symbols) {
                     var nameToSymbol = {};
-                    for (var _i = 0; _i < symbols.length; _i++) {
-                        var symbol = symbols[_i];
+                    for (var _i = 0, symbols_3 = symbols; _i < symbols_3.length; _i++) {
+                        var symbol = symbols_3[_i];
                         var entry = createCompletionEntry(symbol, location);
                         if (entry) {
                             var id = ts.escapeIdentifier(entry.name);
@@ -46844,8 +47291,8 @@ var ts;
                     }
                     var fileNameToDocumentHighlights = {};
                     var result = [];
-                    for (var _i = 0; _i < referencedSymbols.length; _i++) {
-                        var referencedSymbol = referencedSymbols[_i];
+                    for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) {
+                        var referencedSymbol = referencedSymbols_1[_i];
                         for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) {
                             var referenceEntry = _b[_a];
                             var fileName_1 = referenceEntry.fileName;
@@ -46989,7 +47436,6 @@ var ts;
                             ts.forEachChild(node, aggregate);
                         }
                     }
-                    ;
                 }
                 /**
                  * For lack of a better name, this function takes a throw statement and returns the
@@ -47027,7 +47473,6 @@ var ts;
                             ts.forEachChild(node, aggregate);
                         }
                     }
-                    ;
                 }
                 function ownsBreakOrContinueStatement(owner, statement) {
                     var actualOwner = getBreakOrContinueOwner(statement);
@@ -47096,7 +47541,7 @@ var ts;
                         case 219 /* ModuleBlock */:
                         case 248 /* SourceFile */:
                             // Container is either a class declaration or the declaration is a classDeclaration
-                            if (modifierFlag & 256 /* Abstract */) {
+                            if (modifierFlag & 128 /* Abstract */) {
                                 nodes = declaration.members.concat(declaration);
                             }
                             else {
@@ -47111,7 +47556,7 @@ var ts;
                             nodes = container.members;
                             // If we're an accessibility modifier, we're in an instance member and should search
                             // the constructor's parameter list for instance members as well.
-                            if (modifierFlag & 112 /* AccessibilityModifier */) {
+                            if (modifierFlag & 56 /* AccessibilityModifier */) {
                                 var constructor = ts.forEach(container.members, function (member) {
                                     return member.kind === 144 /* Constructor */ && member;
                                 });
@@ -47119,7 +47564,7 @@ var ts;
                                     nodes = nodes.concat(constructor.parameters);
                                 }
                             }
-                            else if (modifierFlag & 256 /* Abstract */) {
+                            else if (modifierFlag & 128 /* Abstract */) {
                                 nodes = nodes.concat(container);
                             }
                             break;
@@ -47135,19 +47580,19 @@ var ts;
                     function getFlagFromModifier(modifier) {
                         switch (modifier) {
                             case 112 /* PublicKeyword */:
-                                return 16 /* Public */;
+                                return 8 /* Public */;
                             case 110 /* PrivateKeyword */:
-                                return 32 /* Private */;
+                                return 16 /* Private */;
                             case 111 /* ProtectedKeyword */:
-                                return 64 /* Protected */;
+                                return 32 /* Protected */;
                             case 113 /* StaticKeyword */:
-                                return 128 /* Static */;
+                                return 64 /* Static */;
                             case 82 /* ExportKeyword */:
-                                return 1 /* Export */;
+                                return 2 /* Export */;
                             case 122 /* DeclareKeyword */:
-                                return 2 /* Ambient */;
+                                return 4 /* Ambient */;
                             case 115 /* AbstractKeyword */:
-                                return 256 /* Abstract */;
+                                return 128 /* Abstract */;
                             default:
                                 ts.Debug.fail();
                         }
@@ -47346,8 +47791,8 @@ var ts;
                     return undefined;
                 }
                 var result = [];
-                for (var _i = 0; _i < documentHighlights.length; _i++) {
-                    var entry = documentHighlights[_i];
+                for (var _i = 0, documentHighlights_1 = documentHighlights; _i < documentHighlights_1.length; _i++) {
+                    var entry = documentHighlights_1[_i];
                     for (var _a = 0, _b = entry.highlightSpans; _a < _b.length; _a++) {
                         var highlightSpan = _b[_a];
                         result.push({
@@ -47365,8 +47810,8 @@ var ts;
                 return undefined;
             }
             var referenceEntries = [];
-            for (var _i = 0; _i < referenceSymbols.length; _i++) {
-                var referenceSymbol = referenceSymbols[_i];
+            for (var _i = 0, referenceSymbols_1 = referenceSymbols; _i < referenceSymbols_1.length; _i++) {
+                var referenceSymbol = referenceSymbols_1[_i];
                 ts.addRange(referenceEntries, referenceSymbol.references);
             }
             return referenceEntries;
@@ -47451,8 +47896,8 @@ var ts;
             }
             else {
                 var internedName = getInternedName(symbol, node, declarations);
-                for (var _i = 0; _i < sourceFiles.length; _i++) {
-                    var sourceFile = sourceFiles[_i];
+                for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) {
+                    var sourceFile = sourceFiles_2[_i];
                     cancellationToken.throwIfCancellationRequested();
                     var nameTable = getNameTable(sourceFile);
                     if (ts.lookUp(nameTable, internedName)) {
@@ -47512,7 +47957,7 @@ var ts;
                 }
                 // If this is private property or method, the scope is the containing class
                 if (symbol.flags & (4 /* Property */ | 8192 /* Method */)) {
-                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 32 /* Private */) ? d : undefined; });
+                    var privateDeclaration = ts.forEach(symbol.getDeclarations(), function (d) { return (d.flags & 16 /* Private */) ? d : undefined; });
                     if (privateDeclaration) {
                         return ts.getAncestor(privateDeclaration, 214 /* ClassDeclaration */);
                     }
@@ -47530,8 +47975,8 @@ var ts;
                 var scope = undefined;
                 var declarations = symbol.getDeclarations();
                 if (declarations) {
-                    for (var _i = 0; _i < declarations.length; _i++) {
-                        var declaration = declarations[_i];
+                    for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
+                        var declaration = declarations_8[_i];
                         var container = getContainerNode(declaration);
                         if (!container) {
                             return undefined;
@@ -47711,7 +48156,7 @@ var ts;
                     return undefined;
                 }
                 // Whether 'super' occurs in a static context within a class.
-                var staticFlag = 128 /* Static */;
+                var staticFlag = 64 /* Static */;
                 switch (searchSpaceNode.kind) {
                     case 141 /* PropertyDeclaration */:
                     case 140 /* PropertySignature */:
@@ -47739,7 +48184,7 @@ var ts;
                     // If we have a 'super' container, we must have an enclosing class.
                     // Now make sure the owning class is the same as the search-space
                     // and has the same static qualifier as the original 'super's owner.
-                    if (container && (128 /* Static */ & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
+                    if (container && (64 /* Static */ & container.flags) === staticFlag && container.parent.symbol === searchSpaceNode.symbol) {
                         references.push(getReferenceEntryFromNode(node));
                     }
                 });
@@ -47749,7 +48194,7 @@ var ts;
             function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles) {
                 var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false);
                 // Whether 'this' occurs in a static context within a class.
-                var staticFlag = 128 /* Static */;
+                var staticFlag = 64 /* Static */;
                 switch (searchSpaceNode.kind) {
                     case 143 /* MethodDeclaration */:
                     case 142 /* MethodSignature */:
@@ -47827,7 +48272,7 @@ var ts;
                             case 214 /* ClassDeclaration */:
                                 // Make sure the container belongs to the same class
                                 // and has the appropriate static modifier from the original container.
-                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 128 /* Static */) === staticFlag) {
+                                if (container.parent && searchSpaceNode.symbol === container.parent.symbol && (container.flags & 64 /* Static */) === staticFlag) {
                                     result.push(getReferenceEntryFromNode(node));
                                 }
                                 break;
@@ -47998,8 +48443,8 @@ var ts;
                         // To achieve that we will keep iterating until the result stabilizes.
                         // Remember the last meaning
                         lastIterationMeaning = meaning;
-                        for (var _i = 0; _i < declarations.length; _i++) {
-                            var declaration = declarations[_i];
+                        for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) {
+                            var declaration = declarations_9[_i];
                             var declarationMeaning = getMeaningFromDeclaration(declaration);
                             if (declarationMeaning & meaning) {
                                 meaning |= declarationMeaning;
@@ -48115,7 +48560,6 @@ var ts;
                     return 4 /* Namespace */ | 1 /* Value */;
             }
             return 1 /* Value */ | 2 /* Type */ | 4 /* Namespace */;
-            ts.Debug.fail("Unknown declaration type");
         }
         function isTypeReference(node) {
             if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) {
@@ -48694,8 +49138,8 @@ var ts;
                 if (matchKind) {
                     var parentElement = token.parent;
                     var childNodes = parentElement.getChildren(sourceFile);
-                    for (var _i = 0; _i < childNodes.length; _i++) {
-                        var current = childNodes[_i];
+                    for (var _i = 0, childNodes_1 = childNodes; _i < childNodes_1.length; _i++) {
+                        var current = childNodes_1[_i];
                         if (current.kind === matchKind) {
                             var range1 = ts.createTextSpan(token.getStart(sourceFile), token.getWidth(sourceFile));
                             var range2 = ts.createTextSpan(current.getStart(sourceFile), current.getWidth(sourceFile));
@@ -49025,8 +49469,8 @@ var ts;
                         // Disallow rename for elements that are defined in the standard TypeScript library.
                         var defaultLibFileName = host.getDefaultLibFileName(host.getCompilationSettings());
                         if (defaultLibFileName) {
-                            for (var _i = 0; _i < declarations.length; _i++) {
-                                var current = declarations[_i];
+                            for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) {
+                                var current = declarations_10[_i];
                                 var sourceFile_2 = current.getSourceFile();
                                 var canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName));
                                 if (sourceFile_2 && getCanonicalFileName(ts.normalizePath(sourceFile_2.fileName)) === getCanonicalFileName(ts.normalizePath(defaultLibFileName))) {
@@ -49609,7 +50053,7 @@ var ts;
          */
         function spanInSourceFileAtLocation(sourceFile, position) {
             // Cannot set breakpoint in dts file
-            if (sourceFile.flags & 8192 /* DeclarationFile */) {
+            if (sourceFile.flags & 4096 /* DeclarationFile */) {
                 return undefined;
             }
             var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position);
@@ -49827,7 +50271,7 @@ var ts;
                             ? variableDeclaration.parent.parent.initializer.declarations
                             : undefined;
                     // Breakpoint is possible in variableDeclaration only if there is initialization
-                    if (variableDeclaration.initializer || (variableDeclaration.flags & 1 /* Export */)) {
+                    if (variableDeclaration.initializer || (variableDeclaration.flags & 2 /* Export */)) {
                         if (declarations && declarations[0] === variableDeclaration) {
                             if (isParentVariableStatement) {
                                 // First declaration - include let keyword
@@ -49853,7 +50297,7 @@ var ts;
                 function canHaveSpanInParameterDeclaration(parameter) {
                     // Breakpoint is possible on parameter only if it has initializer, is a rest parameter, or has public or private modifier
                     return !!parameter.initializer || parameter.dotDotDotToken !== undefined ||
-                        !!(parameter.flags & 16 /* Public */) || !!(parameter.flags & 32 /* Private */);
+                        !!(parameter.flags & 8 /* Public */) || !!(parameter.flags & 16 /* Private */);
                 }
                 function spanInParameterDeclaration(parameter) {
                     if (canHaveSpanInParameterDeclaration(parameter)) {
@@ -49873,7 +50317,7 @@ var ts;
                     }
                 }
                 function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) {
-                    return !!(functionDeclaration.flags & 1 /* Export */) ||
+                    return !!(functionDeclaration.flags & 2 /* Export */) ||
                         (functionDeclaration.parent.kind === 214 /* ClassDeclaration */ && functionDeclaration.kind !== 144 /* Constructor */);
                 }
                 function spanInFunctionDeclaration(functionDeclaration) {
@@ -49967,7 +50411,6 @@ var ts;
                         // fall through.
                         case 244 /* CatchClause */:
                             return spanInNode(ts.lastOrUndefined(node.parent.statements));
-                            ;
                         case 220 /* CaseBlock */:
                             // breakpoint in last statement of the last clause
                             var caseBlock = node.parent;
@@ -50008,8 +50451,6 @@ var ts;
                         default:
                             return spanInNode(node.parent);
                     }
-                    // Default to parent node
-                    return spanInNode(node.parent);
                 }
                 function spanInColonToken(node) {
                     // Is this : specifying return annotation of the function declaration
@@ -50138,7 +50579,6 @@ var ts;
             // TODO: should this be '==='?
             if (settingsJson == null || settingsJson == "") {
                 throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
-                return null;
             }
             return JSON.parse(settingsJson);
         };
diff --git a/scripts/tslint/preferConstRule.ts b/scripts/tslint/preferConstRule.ts
new file mode 100644
index 00000000000..29160a9c634
--- /dev/null
+++ b/scripts/tslint/preferConstRule.ts
@@ -0,0 +1,228 @@
+/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
+/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static FAILURE_STRING_FACTORY = (identifier: string) => `Identifier '${identifier}' never appears on the LHS of an assignment - use const instead of let for its declaration.`;
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new PreferConstWalker(sourceFile, this.getOptions()));
+    }
+}
+
+function isBindingPattern(node: ts.Node): node is ts.BindingPattern {
+    return !!node && (node.kind === ts.SyntaxKind.ArrayBindingPattern || node.kind === ts.SyntaxKind.ObjectBindingPattern);
+}
+
+function walkUpBindingElementsAndPatterns(node: ts.Node): ts.Node {
+    while (node && (node.kind === ts.SyntaxKind.BindingElement || isBindingPattern(node))) {
+        node = node.parent;
+    }
+
+    return node;
+}
+
+function getCombinedNodeFlags(node: ts.Node): ts.NodeFlags {
+    node = walkUpBindingElementsAndPatterns(node);
+
+    let flags = node.flags;
+    if (node.kind === ts.SyntaxKind.VariableDeclaration) {
+        node = node.parent;
+    }
+
+    if (node && node.kind === ts.SyntaxKind.VariableDeclarationList) {
+        flags |= node.flags;
+        node = node.parent;
+    }
+
+    if (node && node.kind === ts.SyntaxKind.VariableStatement) {
+        flags |= node.flags;
+    }
+
+    return flags;
+}
+
+function isLet(node: ts.Node) {
+    return !!(getCombinedNodeFlags(node) & ts.NodeFlags.Let);
+}
+
+function isExported(node: ts.Node) {
+    return !!(getCombinedNodeFlags(node) & ts.NodeFlags.Export);
+}
+
+function isAssignmentOperator(token: ts.SyntaxKind): boolean {
+    return token >= ts.SyntaxKind.FirstAssignment && token <= ts.SyntaxKind.LastAssignment;
+}
+
+function isBindingLiteralExpression(node: ts.Node): node is (ts.ArrayLiteralExpression | ts.ObjectLiteralExpression) {
+    return (!!node) && (node.kind === ts.SyntaxKind.ObjectLiteralExpression || node.kind === ts.SyntaxKind.ArrayLiteralExpression);
+}
+
+interface DeclarationUsages {
+    declaration: ts.VariableDeclaration;
+    usages: number;
+}
+
+class PreferConstWalker extends Lint.RuleWalker {
+    private inScopeLetDeclarations: ts.Map<DeclarationUsages>[] = [];
+    private errors: Lint.RuleFailure[] = [];
+    private markAssignment(identifier: ts.Identifier) {
+        const name = identifier.text;
+        for (let i = this.inScopeLetDeclarations.length - 1; i >= 0; i--) {
+            const declarations = this.inScopeLetDeclarations[i];
+            if (declarations[name]) {
+                declarations[name].usages++;
+                break;
+            }
+        }
+    }
+
+    visitSourceFile(node: ts.SourceFile) {
+        super.visitSourceFile(node);
+        // Sort errors by position because tslint doesn't
+        this.errors.sort((a, b) => a.getStartPosition().getPosition() - b.getStartPosition().getPosition()).forEach(e => this.addFailure(e));
+    }
+
+    visitBinaryExpression(node: ts.BinaryExpression) {
+        if (isAssignmentOperator(node.operatorToken.kind)) {
+            this.visitLHSExpressions(node.left);
+        }
+        super.visitBinaryExpression(node);
+    }
+
+    private visitLHSExpressions(node: ts.Expression) {
+        while (node.kind === ts.SyntaxKind.ParenthesizedExpression) {
+            node = (node as ts.ParenthesizedExpression).expression;
+        }
+        if (node.kind === ts.SyntaxKind.Identifier) {
+            this.markAssignment(node as ts.Identifier);
+        }
+        else if (isBindingLiteralExpression(node)) {
+            this.visitBindingLiteralExpression(node as (ts.ArrayLiteralExpression | ts.ObjectLiteralExpression));
+        }
+    }
+    
+    private visitBindingLiteralExpression(node: ts.ArrayLiteralExpression | ts.ObjectLiteralExpression) {
+        if (node.kind === ts.SyntaxKind.ObjectLiteralExpression) {
+            const pattern = node as ts.ObjectLiteralExpression;
+            for (const element of pattern.properties) {
+                if (element.name.kind === ts.SyntaxKind.Identifier) {
+                    this.markAssignment(element.name as ts.Identifier)
+                }
+                else if (isBindingPattern(element.name)) {
+                    this.visitBindingPatternIdentifiers(element.name as ts.BindingPattern);
+                }
+            }
+        }
+        else if (node.kind === ts.SyntaxKind.ArrayLiteralExpression) {
+            const pattern = node as ts.ArrayLiteralExpression;
+            for (const element of pattern.elements) {
+                this.visitLHSExpressions(element);
+            }
+        }
+    }
+
+    private visitBindingPatternIdentifiers(pattern: ts.BindingPattern) {
+        for (const element of pattern.elements) {
+            if (element.name.kind === ts.SyntaxKind.Identifier) {
+                this.markAssignment(element.name as ts.Identifier);
+            }
+            else {
+                this.visitBindingPatternIdentifiers(element.name as ts.BindingPattern);
+            }
+        }
+    }
+
+    visitPrefixUnaryExpression(node: ts.PrefixUnaryExpression) {
+        this.visitAnyUnaryExpression(node);
+        super.visitPrefixUnaryExpression(node);
+    }
+
+    visitPostfixUnaryExpression(node: ts.PostfixUnaryExpression) {
+        this.visitAnyUnaryExpression(node);
+        super.visitPostfixUnaryExpression(node);
+    }
+
+    private visitAnyUnaryExpression(node: ts.PrefixUnaryExpression | ts.PostfixUnaryExpression) {
+        if (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) {
+            this.visitLHSExpressions(node.operand);
+        }
+    }
+
+    visitModuleDeclaration(node: ts.ModuleDeclaration) {
+        if (node.body.kind === ts.SyntaxKind.ModuleBlock) {
+            // For some reason module blocks are left out of the visit block traversal
+            this.visitBlock(node.body as ts.ModuleBlock);
+        }
+        super.visitModuleDeclaration(node);
+    }
+
+    visitForOfStatement(node: ts.ForOfStatement) {
+        this.visitAnyForStatement(node);
+        super.visitForOfStatement(node);
+        this.popDeclarations();
+    }
+
+    visitForInStatement(node: ts.ForInStatement) {
+        this.visitAnyForStatement(node);
+        super.visitForInStatement(node);
+        this.popDeclarations();
+    }
+
+    private visitAnyForStatement(node: ts.ForOfStatement | ts.ForInStatement) {
+        const names: ts.Map<DeclarationUsages> = {};
+        if (isLet(node.initializer)) {
+            if (node.initializer.kind === ts.SyntaxKind.VariableDeclarationList) {
+                this.collectLetIdentifiers(node.initializer as ts.VariableDeclarationList, names);
+            }
+        }
+        this.inScopeLetDeclarations.push(names);
+    }
+
+    private popDeclarations() {
+        const completed = this.inScopeLetDeclarations.pop();
+        for (const name in completed) {
+            if (Object.hasOwnProperty.call(completed, name)) {
+                const element = completed[name];
+                if (element.usages === 0) {
+                    this.errors.push(this.createFailure(element.declaration.getStart(this.getSourceFile()), element.declaration.getWidth(this.getSourceFile()), Rule.FAILURE_STRING_FACTORY(name)));
+                }
+            }
+        }
+    }
+
+    visitBlock(node: ts.Block) {
+        const names: ts.Map<DeclarationUsages> = {};
+        for (const statement of node.statements) {
+            if (statement.kind === ts.SyntaxKind.VariableStatement) {
+                this.collectLetIdentifiers((statement as ts.VariableStatement).declarationList, names);
+            }
+        }
+        this.inScopeLetDeclarations.push(names);
+        super.visitBlock(node);
+        this.popDeclarations();
+    }
+
+    private collectLetIdentifiers(list: ts.VariableDeclarationList, ret: ts.Map<DeclarationUsages>) {
+        for (const node of list.declarations) {
+            if (isLet(node) && !isExported(node)) {
+                this.collectNameIdentifiers(node, node.name, ret);
+            }
+        }
+    }
+
+    private collectNameIdentifiers(value: ts.VariableDeclaration, node: ts.Identifier | ts.BindingPattern, table: ts.Map<DeclarationUsages>) {
+        if (node.kind === ts.SyntaxKind.Identifier) {
+            table[(node as ts.Identifier).text] = {declaration: value, usages: 0};
+        }
+        else {
+            this.collectBindingPatternIdentifiers(value, node as ts.BindingPattern, table);
+        }
+    }
+
+    private collectBindingPatternIdentifiers(value: ts.VariableDeclaration, pattern: ts.BindingPattern, table: ts.Map<DeclarationUsages>) {
+        for (const element of pattern.elements) {
+            this.collectNameIdentifiers(value, element.name, table);
+        }
+    }
+}
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index c12a9afad62..6edba58cb11 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -10,6 +10,21 @@ namespace ts {
         ConstEnumOnly   = 2
     }
 
+    const enum Reachability {
+        Unintialized        = 1 << 0,
+        Reachable           = 1 << 1,
+        Unreachable         = 1 << 2,
+        ReportedUnreachable = 1 << 3
+    }
+
+    function or(state1: Reachability, state2: Reachability): Reachability {
+        return (state1 | state2) & Reachability.Reachable
+            ? Reachability.Reachable
+            : (state1 & state2) & Reachability.ReportedUnreachable
+                ? Reachability.ReportedUnreachable
+                : Reachability.Unreachable;
+    }
+
     export function getModuleInstanceState(node: Node): ModuleInstanceState {
         // A module is uninstantiated if it contains only
         // 1. interface declarations, type alias declarations
@@ -77,35 +92,64 @@ namespace ts {
         IsContainerWithLocals = IsContainer | HasLocals
     }
 
-    export function bindSourceFile(file: SourceFile) {
-        let start = new Date().getTime();
-        bindSourceFileWorker(file);
+    const binder = createBinder();
+
+    export function bindSourceFile(file: SourceFile, options: CompilerOptions) {
+        const start = new Date().getTime();
+        binder(file, options);
         bindTime += new Date().getTime() - start;
     }
 
-    function bindSourceFileWorker(file: SourceFile) {
+    function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
+        let file: SourceFile;
+        let options: CompilerOptions;
         let parent: Node;
         let container: Node;
         let blockScopeContainer: Node;
         let lastContainer: Node;
         let seenThisKeyword: boolean;
 
+        // state used by reachability checks
+        let hasExplicitReturn: boolean;
+        let currentReachabilityState: Reachability;
+        let labelStack: Reachability[];
+        let labelIndexMap: Map<number>;
+        let implicitLabels: number[];
+
         // If this file is an external module, then it is automatically in strict-mode according to
         // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
         // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
-        let inStrictMode = !!file.externalModuleIndicator;
+        let inStrictMode: boolean;
 
         let symbolCount = 0;
-        let Symbol = objectAllocator.getSymbolConstructor();
-        let classifiableNames: Map<string> = {};
+        let Symbol: { new (flags: SymbolFlags, name: string): Symbol };
+        let classifiableNames: Map<string>;
 
-        if (!file.locals) {
-            bind(file);
-            file.symbolCount = symbolCount;
-            file.classifiableNames = classifiableNames;
+        function bindSourceFile(f: SourceFile, opts: CompilerOptions) {
+            file = f;
+            options = opts;
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            Symbol = objectAllocator.getSymbolConstructor();
+
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            hasExplicitReturn = false;
+            labelStack = undefined;
+            labelIndexMap = undefined;
+            implicitLabels = undefined;
         }
 
-        return;
+        return bindSourceFile;
 
         function createSymbol(flags: SymbolFlags, name: string): Symbol {
             symbolCount++;
@@ -143,7 +187,7 @@ namespace ts {
                     return `"${(<LiteralExpression>node.name).text}"`;
                 }
                 if (node.name.kind === SyntaxKind.ComputedPropertyName) {
-                    let nameExpression = (<ComputedPropertyName>node.name).expression;
+                    const nameExpression = (<ComputedPropertyName>node.name).expression;
                     Debug.assert(isWellKnownSymbolSyntactically(nameExpression));
                     return getPropertyNameForKnownSymbolName((<PropertyAccessExpression>nameExpression).name.text);
                 }
@@ -185,9 +229,9 @@ namespace ts {
         function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
             Debug.assert(!hasDynamicName(node));
 
-            let isDefaultExport = node.flags & NodeFlags.Default;
+            const isDefaultExport = node.flags & NodeFlags.Default;
             // The exported symbol for an export default function/class node is always named "default"
-            let name = isDefaultExport && parent ? "default" : getDeclarationName(node);
+            const name = isDefaultExport && parent ? "default" : getDeclarationName(node);
 
             let symbol: Symbol;
             if (name !== undefined) {
@@ -254,7 +298,7 @@ namespace ts {
         }
 
         function declareModuleMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {
-            let hasExportModifier = getCombinedNodeFlags(node) & NodeFlags.Export;
+            const hasExportModifier = getCombinedNodeFlags(node) & NodeFlags.Export;
             if (symbolFlags & SymbolFlags.Alias) {
                 if (node.kind === SyntaxKind.ExportSpecifier || (node.kind === SyntaxKind.ImportEqualsDeclaration && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -276,11 +320,11 @@ namespace ts {
                 //      but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way
                 //      when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.
                 if (hasExportModifier || container.flags & NodeFlags.ExportContext) {
-                    let exportKind =
+                    const exportKind =
                         (symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0) |
                         (symbolFlags & SymbolFlags.Type ? SymbolFlags.ExportType : 0) |
                         (symbolFlags & SymbolFlags.Namespace ? SymbolFlags.ExportNamespace : 0);
-                    let local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
+                    const local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
                     local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
                     node.localSymbol = local;
                     return local;
@@ -298,9 +342,9 @@ namespace ts {
             // Before we recurse into a node's chilren, we first save the existing parent, container
             // and block-container.  Then after we pop out of processing the children, we restore
             // these saved values.
-            let saveParent = parent;
-            let saveContainer = container;
-            let savedBlockScopeContainer = blockScopeContainer;
+            const saveParent = parent;
+            const saveContainer = container;
+            const savedBlockScopeContainer = blockScopeContainer;
 
             // This node will now be set as the parent of all of its children as we recurse into them.
             parent = node;
@@ -322,7 +366,7 @@ namespace ts {
             // reusing a node from a previous compilation, that node may have had 'locals' created
             // for it.  We must clear this so we don't accidently move any stale data forward from
             // a previous compilation.
-            let containerFlags = getContainerFlags(node);
+            const containerFlags = getContainerFlags(node);
             if (containerFlags & ContainerFlags.IsContainer) {
                 container = blockScopeContainer = node;
 
@@ -338,13 +382,56 @@ namespace ts {
                 blockScopeContainer.locals = undefined;
             }
 
-            if (node.kind === SyntaxKind.InterfaceDeclaration) {
+            let savedReachabilityState: Reachability;
+            let savedLabelStack: Reachability[];
+            let savedLabels: Map<number>;
+            let savedImplicitLabels: number[];
+            let savedHasExplicitReturn: boolean;
+
+            const kind = node.kind;
+            let flags = node.flags;
+
+            // reset all reachability check related flags on node (for incremental scenarios)
+            flags &= ~NodeFlags.ReachabilityCheckFlags;
+
+            if (kind === SyntaxKind.InterfaceDeclaration) {
                 seenThisKeyword = false;
-                forEachChild(node, bind);
-                node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis;
             }
-            else {
-                forEachChild(node, bind);
+
+            const saveState = kind === SyntaxKind.SourceFile || kind === SyntaxKind.ModuleBlock || isFunctionLikeKind(kind);
+            if (saveState) {
+                savedReachabilityState = currentReachabilityState;
+                savedLabelStack = labelStack;
+                savedLabels = labelIndexMap;
+                savedImplicitLabels = implicitLabels;
+                savedHasExplicitReturn = hasExplicitReturn;
+
+                currentReachabilityState = Reachability.Reachable;
+                hasExplicitReturn = false;
+                labelStack = labelIndexMap = implicitLabels = undefined;
+            }
+
+            bindReachableStatement(node);
+
+            if (currentReachabilityState === Reachability.Reachable && isFunctionLikeKind(kind) && nodeIsPresent((<FunctionLikeDeclaration>node).body)) {
+                flags |= NodeFlags.HasImplicitReturn;
+                if (hasExplicitReturn) {
+                    flags |= NodeFlags.HasExplicitReturn;
+                }
+            }
+
+            if (kind === SyntaxKind.InterfaceDeclaration) {
+                flags = seenThisKeyword ? flags | NodeFlags.ContainsThis : flags & ~NodeFlags.ContainsThis;
+            }
+
+            node.flags = flags;
+
+            if (saveState) {
+                hasExplicitReturn = savedHasExplicitReturn;
+                currentReachabilityState = savedReachabilityState;
+                labelStack = savedLabelStack;
+                labelIndexMap = savedLabels;
+                implicitLabels = savedImplicitLabels;
             }
 
             container = saveContainer;
@@ -352,6 +439,220 @@ namespace ts {
             blockScopeContainer = savedBlockScopeContainer;
         }
 
+        /**
+         * Returns true if node and its subnodes were successfully traversed.
+         * Returning false means that node was not examined and caller needs to dive into the node himself. 
+         */
+        function bindReachableStatement(node: Node): void {
+            if (checkUnreachable(node)) {
+                forEachChild(node, bind);
+                return;
+            }
+
+            switch (node.kind) {
+                case SyntaxKind.WhileStatement:
+                    bindWhileStatement(<WhileStatement>node);
+                    break;
+                case SyntaxKind.DoStatement:
+                    bindDoStatement(<DoStatement>node);
+                    break;
+                case SyntaxKind.ForStatement:
+                    bindForStatement(<ForStatement>node);
+                    break;
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                    bindForInOrForOfStatement(<ForInStatement | ForOfStatement>node);
+                    break;
+                case SyntaxKind.IfStatement:
+                    bindIfStatement(<IfStatement>node);
+                    break;
+                case SyntaxKind.ReturnStatement:
+                case SyntaxKind.ThrowStatement:
+                    bindReturnOrThrow(<ReturnStatement | ThrowStatement>node);
+                    break;
+                case SyntaxKind.BreakStatement:
+                case SyntaxKind.ContinueStatement:
+                    bindBreakOrContinueStatement(<BreakOrContinueStatement>node);
+                    break;
+                case SyntaxKind.TryStatement:
+                    bindTryStatement(<TryStatement>node);
+                    break;
+                case SyntaxKind.SwitchStatement:
+                    bindSwitchStatement(<SwitchStatement>node);
+                    break;
+                case SyntaxKind.CaseBlock:
+                    bindCaseBlock(<CaseBlock>node);
+                    break;
+                case SyntaxKind.LabeledStatement:
+                    bindLabeledStatement(<LabeledStatement>node);
+                    break;
+                default:
+                    forEachChild(node, bind);
+                    break;
+            }
+        }
+
+        function bindWhileStatement(n: WhileStatement): void {
+            const preWhileState =
+                n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState;
+            const postWhileState =
+                n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : currentReachabilityState;
+
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+
+            currentReachabilityState = preWhileState;
+            const postWhileLabel = pushImplicitLabel();
+            bind(n.statement);
+            popImplicitLabel(postWhileLabel, postWhileState);
+        }
+
+        function bindDoStatement(n: DoStatement): void {
+            const preDoState = currentReachabilityState;
+
+            const postDoLabel = pushImplicitLabel();
+            bind(n.statement);
+            const postDoState = n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : preDoState;
+            popImplicitLabel(postDoLabel, postDoState);
+
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+        }
+
+        function bindForStatement(n: ForStatement): void {
+            const preForState = currentReachabilityState;
+            const postForLabel = pushImplicitLabel();
+
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.condition);
+            bind(n.incrementor);
+
+            bind(n.statement);
+
+            // for statement is considered infinite when it condition is either omitted or is true keyword
+            // - for(..;;..)
+            // - for(..;true;..)
+            const isInfiniteLoop = (!n.condition || n.condition.kind === SyntaxKind.TrueKeyword);
+            const postForState = isInfiniteLoop ? Reachability.Unreachable : preForState;
+            popImplicitLabel(postForLabel, postForState);
+        }
+
+        function bindForInOrForOfStatement(n: ForInStatement | ForOfStatement): void {
+            const preStatementState = currentReachabilityState;
+            const postStatementLabel = pushImplicitLabel();
+
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.expression);
+
+            bind(n.statement);
+            popImplicitLabel(postStatementLabel, preStatementState);
+        }
+
+        function bindIfStatement(n: IfStatement): void {
+            // denotes reachability state when entering 'thenStatement' part of the if statement: 
+            // i.e. if condition is false then thenStatement is unreachable
+            const ifTrueState = n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState;
+            // denotes reachability state when entering 'elseStatement':
+            // i.e. if condition is true then elseStatement is unreachable
+            const ifFalseState = n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : currentReachabilityState;
+
+            currentReachabilityState = ifTrueState;
+
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+
+            bind(n.thenStatement);
+            if (n.elseStatement) {
+                const preElseState = currentReachabilityState;
+                currentReachabilityState = ifFalseState;
+                bind(n.elseStatement);
+                currentReachabilityState = or(currentReachabilityState, preElseState);
+            }
+            else {
+                currentReachabilityState = or(currentReachabilityState, ifFalseState);
+            }
+        }
+
+        function bindReturnOrThrow(n: ReturnStatement | ThrowStatement): void {
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            if (n.kind === SyntaxKind.ReturnStatement) {
+                hasExplicitReturn = true;
+            }
+            currentReachabilityState = Reachability.Unreachable;
+        }
+
+        function bindBreakOrContinueStatement(n: BreakOrContinueStatement): void {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+            // for continue case touch label so it will be marked a used
+            const isValidJump = jumpToLabel(n.label, n.kind === SyntaxKind.BreakStatement ? currentReachabilityState : Reachability.Unreachable);
+            if (isValidJump) {
+                currentReachabilityState = Reachability.Unreachable;
+            }
+        }
+
+        function bindTryStatement(n: TryStatement): void {
+            // catch\finally blocks has the same reachability as try block
+            const preTryState = currentReachabilityState;
+            bind(n.tryBlock);
+            const postTryState = currentReachabilityState;
+
+            currentReachabilityState = preTryState;
+            bind(n.catchClause);
+            const postCatchState = currentReachabilityState;
+
+            currentReachabilityState = preTryState;
+            bind(n.finallyBlock);
+
+            // post catch/finally state is reachable if
+            // - post try state is reachable - control flow can fall out of try block
+            // - post catch state is reachable - control flow can fall out of catch block
+            currentReachabilityState = or(postTryState, postCatchState);
+        }
+
+        function bindSwitchStatement(n: SwitchStatement): void {
+            const preSwitchState = currentReachabilityState;
+            const postSwitchLabel = pushImplicitLabel();
+
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+
+            bind(n.caseBlock);
+
+            const hasDefault = forEach(n.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause);
+
+            // post switch state is unreachable if switch is exaustive (has a default case ) and does not have fallthrough from the last case
+            const postSwitchState = hasDefault && currentReachabilityState !== Reachability.Reachable ? Reachability.Unreachable : preSwitchState;
+
+            popImplicitLabel(postSwitchLabel, postSwitchState);
+        }
+
+        function bindCaseBlock(n: CaseBlock): void {
+            const startState = currentReachabilityState;
+
+            for (const clause of n.clauses) {
+                currentReachabilityState = startState;
+                bind(clause);
+                if (clause.statements.length && currentReachabilityState === Reachability.Reachable && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+
+        function bindLabeledStatement(n: LabeledStatement): void {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+
+            const ok = pushNamedLabel(n.label);
+            bind(n.statement);
+            if (ok) {
+                popNamedLabel(n.label, currentReachabilityState);
+            }
+        }
+
         function getContainerFlags(node: Node): ContainerFlags {
             switch (node.kind) {
                 case SyntaxKind.ClassExpression:
@@ -488,21 +789,10 @@ namespace ts {
                 : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
         }
 
-        function isAmbientContext(node: Node): boolean {
-            while (node) {
-                if (node.flags & NodeFlags.Ambient) {
-                    return true;
-                }
-
-                node = node.parent;
-            }
-            return false;
-        }
-
         function hasExportDeclarations(node: ModuleDeclaration | SourceFile): boolean {
-            let body = node.kind === SyntaxKind.SourceFile ? node : (<ModuleDeclaration>node).body;
+            const body = node.kind === SyntaxKind.SourceFile ? node : (<ModuleDeclaration>node).body;
             if (body.kind === SyntaxKind.SourceFile || body.kind === SyntaxKind.ModuleBlock) {
-                for (let stat of (<Block>body).statements) {
+                for (const stat of (<Block>body).statements) {
                     if (stat.kind === SyntaxKind.ExportDeclaration || stat.kind === SyntaxKind.ExportAssignment) {
                         return true;
                     }
@@ -514,7 +804,7 @@ namespace ts {
         function setExportContextFlag(node: ModuleDeclaration | SourceFile) {
             // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular
             // declarations with export modifiers) is an export context in which declarations are implicitly exported.
-            if (isAmbientContext(node) && !hasExportDeclarations(node)) {
+            if (isInAmbientContext(node) && !hasExportDeclarations(node)) {
                 node.flags |= NodeFlags.ExportContext;
             }
             else {
@@ -528,7 +818,7 @@ namespace ts {
                 declareSymbolAndAddToSymbolTable(node, SymbolFlags.ValueModule, SymbolFlags.ValueModuleExcludes);
             }
             else {
-                let state = getModuleInstanceState(node);
+                const state = getModuleInstanceState(node);
                 if (state === ModuleInstanceState.NonInstantiated) {
                     declareSymbolAndAddToSymbolTable(node, SymbolFlags.NamespaceModule, SymbolFlags.NamespaceModuleExcludes);
                 }
@@ -540,7 +830,7 @@ namespace ts {
                         node.symbol.constEnumOnlyModule = false;
                     }
                     else {
-                        let currentModuleIsConstEnumOnly = state === ModuleInstanceState.ConstEnumOnly;
+                        const currentModuleIsConstEnumOnly = state === ModuleInstanceState.ConstEnumOnly;
                         if (node.symbol.constEnumOnlyModule === undefined) {
                             // non-merged case - use the current state
                             node.symbol.constEnumOnlyModule = currentModuleIsConstEnumOnly;
@@ -561,10 +851,10 @@ namespace ts {
             // We do that by making an anonymous type literal symbol, and then setting the function
             // symbol as its sole member. To the rest of the system, this symbol will be  indistinguishable
             // from an actual type literal symbol you would have gotten had you used the long form.
-            let symbol = createSymbol(SymbolFlags.Signature, getDeclarationName(node));
+            const symbol = createSymbol(SymbolFlags.Signature, getDeclarationName(node));
             addDeclarationToSymbol(symbol, node, SymbolFlags.Signature);
 
-            let typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
+            const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
             addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);
             typeLiteralSymbol.members = { [symbol.name]: symbol };
         }
@@ -576,14 +866,14 @@ namespace ts {
             }
 
             if (inStrictMode) {
-                let seen: Map<ElementKind> = {};
+                const seen: Map<ElementKind> = {};
 
-                for (let prop of node.properties) {
+                for (const prop of node.properties) {
                     if (prop.name.kind !== SyntaxKind.Identifier) {
                         continue;
                     }
 
-                    let identifier = <Identifier>prop.name;
+                    const identifier = <Identifier>prop.name;
 
                     // ECMA-262 11.1.5 Object Initialiser
                     // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
@@ -593,18 +883,18 @@ namespace ts {
                     //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
                     //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true
                     // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields
-                    let currentKind = prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment || prop.kind === SyntaxKind.MethodDeclaration
+                    const currentKind = prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment || prop.kind === SyntaxKind.MethodDeclaration
                         ? ElementKind.Property
                         : ElementKind.Accessor;
 
-                    let existingKind = seen[identifier.text];
+                    const existingKind = seen[identifier.text];
                     if (!existingKind) {
                         seen[identifier.text] = currentKind;
                         continue;
                     }
 
                     if (currentKind === ElementKind.Property && existingKind === ElementKind.Property) {
-                        let span = getErrorSpanForNode(file, identifier);
+                        const span = getErrorSpanForNode(file, identifier);
                         file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length,
                             Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));
                     }
@@ -615,7 +905,7 @@ namespace ts {
         }
 
         function bindAnonymousDeclaration(node: Declaration, symbolFlags: SymbolFlags, name: string) {
-            let symbol = createSymbol(symbolFlags, name);
+            const symbol = createSymbol(symbolFlags, name);
             addDeclarationToSymbol(symbol, node, symbolFlags);
         }
 
@@ -694,7 +984,7 @@ namespace ts {
             if (inStrictMode && node.expression.kind === SyntaxKind.Identifier) {
                 // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its
                 // UnaryExpression is a direct reference to a variable, function argument, or function name
-                let span = getErrorSpanForNode(file, node.expression);
+                const span = getErrorSpanForNode(file, node.expression);
                 file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
             }
         }
@@ -706,11 +996,11 @@ namespace ts {
 
         function checkStrictModeEvalOrArguments(contextNode: Node, name: Node) {
             if (name && name.kind === SyntaxKind.Identifier) {
-                let identifier = <Identifier>name;
+                const identifier = <Identifier>name;
                 if (isEvalOrArgumentsIdentifier(identifier)) {
                     // We check first if the name is inside class declaration or class expression; if so give explicit message
                     // otherwise report generic error message.
-                    let span = getErrorSpanForNode(file, name);
+                    const span = getErrorSpanForNode(file, name);
                     file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length,
                         getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text));
                 }
@@ -766,12 +1056,12 @@ namespace ts {
         function checkStrictModeWithStatement(node: WithStatement) {
             // Grammar checking for withStatement
             if (inStrictMode) {
-                grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                errorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
             }
         }
 
-        function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any) {
-            let span = getSpanOfTokenAtPosition(file, node.pos);
+        function errorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any) {
+            const span = getSpanOfTokenAtPosition(file, node.pos);
             file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
         }
 
@@ -780,9 +1070,13 @@ namespace ts {
         }
 
         function bind(node: Node) {
+            if (!node) {
+                return;
+            }
+
             node.parent = parent;
 
-            let savedInStrictMode = inStrictMode;
+            const savedInStrictMode = inStrictMode;
             if (!savedInStrictMode) {
                 updateStrictMode(node);
             }
@@ -828,7 +1122,7 @@ namespace ts {
         }
 
         function updateStrictModeStatementList(statements: NodeArray<Statement>) {
-            for (let statement of statements) {
+            for (const statement of statements) {
                 if (!isPrologueDirective(statement)) {
                     return;
                 }
@@ -842,7 +1136,7 @@ namespace ts {
 
         /// Should be called only on prologue directives (isPrologueDirective(node) should be true)
         function isUseStrictPrologueDirective(node: ExpressionStatement): boolean {
-            let nodeText = getTextOfNodeFromSourceText(file.text, node.expression);
+            const nodeText = getTextOfNodeFromSourceText(file.text, node.expression);
 
             // Note: the node text must be exactly "use strict" or 'use strict'.  It is not ok for the
             // string to contain unicode escapes (as per ES5).
@@ -917,7 +1211,7 @@ namespace ts {
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
                     checkStrictModeFunctionName(<FunctionExpression>node);
-                    let bindingName = (<FunctionExpression>node).name ? (<FunctionExpression>node).name.text : "__function";
+                    const bindingName = (<FunctionExpression>node).name ? (<FunctionExpression>node).name.text : "__function";
                     return bindAnonymousDeclaration(<FunctionExpression>node, SymbolFlags.Function, bindingName);
                 case SyntaxKind.ClassExpression:
                 case SyntaxKind.ClassDeclaration:
@@ -990,7 +1284,7 @@ namespace ts {
                 bindBlockScopedDeclaration(node, SymbolFlags.Class, SymbolFlags.ClassExcludes);
             }
             else {
-                let bindingName = node.name ? node.name.text : "__class";
+                const bindingName = node.name ? node.name.text : "__class";
                 bindAnonymousDeclaration(node, SymbolFlags.Class, bindingName);
                 // Add name of class expression into the map for semantic classifier
                 if (node.name) {
@@ -998,7 +1292,7 @@ namespace ts {
                 }
             }
 
-            let symbol = node.symbol;
+            const symbol = node.symbol;
 
             // TypeScript 1.0 spec (April 2014): 8.4
             // Every class automatically contains a static property member named 'prototype', the
@@ -1009,7 +1303,7 @@ namespace ts {
             // Note: we check for this here because this class may be merging into a module.  The
             // module might have an exported variable called 'prototype'.  We can't allow that as
             // that would clash with the built-in 'prototype' for the class.
-            let prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
+            const prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
             if (hasProperty(symbol.exports, prototypeSymbol.name)) {
                 if (node.name) {
                     node.name.parent = node;
@@ -1074,7 +1368,7 @@ namespace ts {
                 node.parent.kind === SyntaxKind.Constructor &&
                 isClassLike(node.parent.parent)) {
 
-                let classDeclaration = <ClassLikeDeclaration>node.parent.parent;
+                const classDeclaration = <ClassLikeDeclaration>node.parent.parent;
                 declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
             }
         }
@@ -1084,5 +1378,135 @@ namespace ts {
                 ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
+
+        // reachability checks
+
+        function pushNamedLabel(name: Identifier): boolean {
+            initializeReachabilityStateIfNecessary();
+
+            if (hasProperty(labelIndexMap, name.text)) {
+                return false;
+            }
+            labelIndexMap[name.text] = labelStack.push(Reachability.Unintialized) - 1;
+            return true;
+        }
+
+        function pushImplicitLabel(): number {
+            initializeReachabilityStateIfNecessary();
+
+            const index = labelStack.push(Reachability.Unintialized) - 1;
+            implicitLabels.push(index);
+            return index;
+        }
+
+        function popNamedLabel(label: Identifier, outerState: Reachability): void {
+            const index = labelIndexMap[label.text];
+            Debug.assert(index !== undefined);
+            Debug.assert(labelStack.length == index + 1);
+
+            labelIndexMap[label.text] = undefined;
+
+            setCurrentStateAtLabel(labelStack.pop(), outerState, label);
+        }
+
+        function popImplicitLabel(implicitLabelIndex: number, outerState: Reachability): void {
+            if (labelStack.length !== implicitLabelIndex + 1) {
+                Debug.assert(false, `Label stack: ${labelStack.length}, index:${implicitLabelIndex}`);
+            }
+
+            const i = implicitLabels.pop();
+
+            if (implicitLabelIndex !== i) {
+                Debug.assert(false, `i: ${i}, index: ${implicitLabelIndex}`);
+            }
+
+            setCurrentStateAtLabel(labelStack.pop(), outerState, /*name*/ undefined);
+        }
+
+        function setCurrentStateAtLabel(innerMergedState: Reachability, outerState: Reachability, label: Identifier): void {
+            if (innerMergedState === Reachability.Unintialized) {
+                if (label && !options.allowUnusedLabels) {
+                    file.bindDiagnostics.push(createDiagnosticForNode(label, Diagnostics.Unused_label));
+                }
+                currentReachabilityState = outerState;
+            }
+            else {
+                currentReachabilityState = or(innerMergedState, outerState);
+            }
+        }
+
+        function jumpToLabel(label: Identifier, outerState: Reachability): boolean {
+            initializeReachabilityStateIfNecessary();
+
+            const index = label ? labelIndexMap[label.text] : lastOrUndefined(implicitLabels);
+            if (index === undefined) {
+                // reference to unknown label or
+                // break/continue used outside of loops
+                return false;
+            }
+            const stateAtLabel = labelStack[index];
+            labelStack[index] = stateAtLabel === Reachability.Unintialized ? outerState : or(stateAtLabel, outerState);
+            return true;
+        }
+
+        function checkUnreachable(node: Node): boolean {
+            switch (currentReachabilityState) {
+                case Reachability.Unreachable:
+                    const reportError =
+                        // report error on all statements except empty ones
+                        (isStatement(node) && node.kind !== SyntaxKind.EmptyStatement) ||
+                        // report error on class declarations
+                        node.kind === SyntaxKind.ClassDeclaration ||
+                        // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+                        (node.kind === SyntaxKind.ModuleDeclaration && shouldReportErrorOnModuleDeclaration(<ModuleDeclaration>node)) ||
+                        // report error on regular enums and const enums if preserveConstEnums is set
+                        (node.kind === SyntaxKind.EnumDeclaration && (!isConstEnumDeclaration(node) || options.preserveConstEnums));
+
+                    if (reportError) {
+                        currentReachabilityState = Reachability.ReportedUnreachable;
+
+                        // unreachable code is reported if
+                        // - user has explicitly asked about it AND
+                        // - statement is in not ambient context (statements in ambient context is already an error 
+                        //   so we should not report extras) AND
+                        //   - node is not variable statement OR
+                        //   - node is block scoped variable statement OR
+                        //   - node is not block scoped variable statement and at least one variable declaration has initializer
+                        //   Rationale: we don't want to report errors on non-initialized var's since they are hoisted
+                        //   On the other side we do want to report errors on non-initialized 'lets' because of TDZ
+                        const reportUnreachableCode =
+                            !options.allowUnreachableCode &&
+                            !isInAmbientContext(node) &&
+                            (
+                                node.kind !== SyntaxKind.VariableStatement ||
+                                getCombinedNodeFlags((<VariableStatement>node).declarationList) & NodeFlags.BlockScoped ||
+                                forEach((<VariableStatement>node).declarationList.declarations, d => d.initializer)
+                            );
+
+                        if (reportUnreachableCode) {
+                            errorOnFirstToken(node, Diagnostics.Unreachable_code_detected);
+                        }
+                    }
+                case Reachability.ReportedUnreachable:
+                    return true;
+                default:
+                    return false;
+            }
+
+            function shouldReportErrorOnModuleDeclaration(node: ModuleDeclaration): boolean {
+                const instanceState = getModuleInstanceState(node);
+                return instanceState === ModuleInstanceState.Instantiated || (instanceState === ModuleInstanceState.ConstEnumOnly && options.preserveConstEnums);
+            }
+        }
+
+        function initializeReachabilityStateIfNecessary(): void {
+            if (labelIndexMap) {
+                return;
+            }
+            currentReachabilityState = Reachability.Reachable;
+            labelIndexMap = {};
+            labelStack = [];
+            implicitLabels = [];
+        }
     }
 }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2e8cd5f7eb2..fe0111a66b9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -33,26 +33,26 @@ namespace ts {
         // they no longer need the information (for example, if the user started editing again).
         let cancellationToken: CancellationToken;
 
-        let Symbol = objectAllocator.getSymbolConstructor();
-        let Type = objectAllocator.getTypeConstructor();
-        let Signature = objectAllocator.getSignatureConstructor();
+        const Symbol = objectAllocator.getSymbolConstructor();
+        const Type = objectAllocator.getTypeConstructor();
+        const Signature = objectAllocator.getSignatureConstructor();
 
         let typeCount = 0;
         let symbolCount = 0;
 
-        let emptyArray: any[] = [];
-        let emptySymbols: SymbolTable = {};
+        const emptyArray: any[] = [];
+        const emptySymbols: SymbolTable = {};
 
-        let compilerOptions = host.getCompilerOptions();
-        let languageVersion = compilerOptions.target || ScriptTarget.ES3;
-        let modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None;
+        const compilerOptions = host.getCompilerOptions();
+        const languageVersion = compilerOptions.target || ScriptTarget.ES3;
+        const modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None;
 
-        let emitResolver = createResolver();
+        const emitResolver = createResolver();
 
-        let undefinedSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "undefined");
-        let argumentsSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "arguments");
+        const undefinedSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "undefined");
+        const argumentsSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "arguments");
 
-        let checker: TypeChecker = {
+        const checker: TypeChecker = {
             getNodeCount: () => sum(host.getSourceFiles(), "nodeCount"),
             getIdentifierCount: () => sum(host.getSourceFiles(), "identifierCount"),
             getSymbolCount: () => sum(host.getSourceFiles(), "symbolCount") + symbolCount,
@@ -97,35 +97,35 @@ namespace ts {
             isOptionalParameter
         };
 
-        let unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
-        let resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__");
+        const unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
+        const resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__");
 
-        let anyType = createIntrinsicType(TypeFlags.Any, "any");
-        let stringType = createIntrinsicType(TypeFlags.String, "string");
-        let numberType = createIntrinsicType(TypeFlags.Number, "number");
-        let booleanType = createIntrinsicType(TypeFlags.Boolean, "boolean");
-        let esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol");
-        let voidType = createIntrinsicType(TypeFlags.Void, "void");
-        let undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsUndefinedOrNull, "undefined");
-        let nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null");
-        let unknownType = createIntrinsicType(TypeFlags.Any, "unknown");
-        let circularType = createIntrinsicType(TypeFlags.Any, "__circular__");
+        const anyType = createIntrinsicType(TypeFlags.Any, "any");
+        const stringType = createIntrinsicType(TypeFlags.String, "string");
+        const numberType = createIntrinsicType(TypeFlags.Number, "number");
+        const booleanType = createIntrinsicType(TypeFlags.Boolean, "boolean");
+        const esSymbolType = createIntrinsicType(TypeFlags.ESSymbol, "symbol");
+        const voidType = createIntrinsicType(TypeFlags.Void, "void");
+        const undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsUndefinedOrNull, "undefined");
+        const nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null");
+        const unknownType = createIntrinsicType(TypeFlags.Any, "unknown");
+        const circularType = createIntrinsicType(TypeFlags.Any, "__circular__");
 
-        let emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
-        let emptyGenericType = <GenericType><ObjectType>createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        const emptyGenericType = <GenericType><ObjectType>createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         emptyGenericType.instantiations = {};
 
-        let anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated
         // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.
         anyFunctionType.flags |= TypeFlags.ContainsAnyFunctionType;
 
-        let noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
 
-        let anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false);
-        let unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false);
+        const anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false);
+        const unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false);
 
-        let globals: SymbolTable = {};
+        const globals: SymbolTable = {};
 
         let globalESSymbolConstructorSymbol: Symbol;
 
@@ -160,29 +160,31 @@ namespace ts {
         let getGlobalPromiseConstructorLikeType: () => ObjectType;
         let getGlobalThenableType: () => ObjectType;
 
-        let tupleTypes: Map<TupleType> = {};
-        let unionTypes: Map<UnionType> = {};
-        let intersectionTypes: Map<IntersectionType> = {};
-        let stringLiteralTypes: Map<StringLiteralType> = {};
+        let jsxElementClassType: Type;
+
+        const tupleTypes: Map<TupleType> = {};
+        const unionTypes: Map<UnionType> = {};
+        const intersectionTypes: Map<IntersectionType> = {};
+        const stringLiteralTypes: Map<StringLiteralType> = {};
         let emitExtends = false;
         let emitDecorate = false;
         let emitParam = false;
         let emitAwaiter = false;
-        let emitGenerator = false;
+        const emitGenerator = false;
 
-        let resolutionTargets: TypeSystemEntity[] = [];
-        let resolutionResults: boolean[] = [];
-        let resolutionPropertyNames: TypeSystemPropertyName[] = [];
+        const resolutionTargets: TypeSystemEntity[] = [];
+        const resolutionResults: boolean[] = [];
+        const resolutionPropertyNames: TypeSystemPropertyName[] = [];
 
-        let mergedSymbols: Symbol[] = [];
-        let symbolLinks: SymbolLinks[] = [];
-        let nodeLinks: NodeLinks[] = [];
-        let potentialThisCollisions: Node[] = [];
-        let awaitedTypeStack: number[] = [];
+        const mergedSymbols: Symbol[] = [];
+        const symbolLinks: SymbolLinks[] = [];
+        const nodeLinks: NodeLinks[] = [];
+        const potentialThisCollisions: Node[] = [];
+        const awaitedTypeStack: number[] = [];
 
-        let diagnostics = createDiagnosticCollection();
+        const diagnostics = createDiagnosticCollection();
 
-        let primitiveTypeInfo: Map<{ type: Type; flags: TypeFlags }> = {
+        const primitiveTypeInfo: Map<{ type: Type; flags: TypeFlags }> = {
             "string": {
                 type: stringType,
                 flags: TypeFlags.StringLike
@@ -209,9 +211,9 @@ namespace ts {
             Element: "Element"
         };
 
-        let subtypeRelation: Map<RelationComparisonResult> = {};
-        let assignableRelation: Map<RelationComparisonResult> = {};
-        let identityRelation: Map<RelationComparisonResult> = {};
+        const subtypeRelation: Map<RelationComparisonResult> = {};
+        const assignableRelation: Map<RelationComparisonResult> = {};
+        const identityRelation: Map<RelationComparisonResult> = {};
 
         // This is for caching the result of getSymbolDisplayBuilder. Do not access directly.
         let _displayBuilder: SymbolDisplayBuilder;
@@ -237,7 +239,7 @@ namespace ts {
         }
 
         function error(location: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): void {
-            let diagnostic = location
+            const diagnostic = location
                 ? createDiagnosticForNode(location, message, arg0, arg1, arg2)
                 : createCompilerDiagnostic(message, arg0, arg1, arg2);
             diagnostics.add(diagnostic);
@@ -275,7 +277,7 @@ namespace ts {
         }
 
         function cloneSymbol(symbol: Symbol): Symbol {
-            let result = createSymbol(symbol.flags | SymbolFlags.Merged, symbol.name);
+            const result = createSymbol(symbol.flags | SymbolFlags.Merged, symbol.name);
             result.declarations = symbol.declarations.slice(0);
             result.parent = symbol.parent;
             if (symbol.valueDeclaration) result.valueDeclaration = symbol.valueDeclaration;
@@ -308,7 +310,7 @@ namespace ts {
                 recordMergedSymbol(target, source);
             }
             else {
-                let message = target.flags & SymbolFlags.BlockScopedVariable || source.flags & SymbolFlags.BlockScopedVariable
+                const message = target.flags & SymbolFlags.BlockScopedVariable || source.flags & SymbolFlags.BlockScopedVariable
                     ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
                 forEach(source.declarations, node => {
                     error(node.name ? node.name : node, message, symbolToString(source));
@@ -320,8 +322,8 @@ namespace ts {
         }
 
         function cloneSymbolTable(symbolTable: SymbolTable): SymbolTable {
-            let result: SymbolTable = {};
-            for (let id in symbolTable) {
+            const result: SymbolTable = {};
+            for (const id in symbolTable) {
                 if (hasProperty(symbolTable, id)) {
                     result[id] = symbolTable[id];
                 }
@@ -330,7 +332,7 @@ namespace ts {
         }
 
         function mergeSymbolTable(target: SymbolTable, source: SymbolTable) {
-            for (let id in source) {
+            for (const id in source) {
                 if (hasProperty(source, id)) {
                     if (!hasProperty(target, id)) {
                         target[id] = source[id];
@@ -348,12 +350,12 @@ namespace ts {
 
         function getSymbolLinks(symbol: Symbol): SymbolLinks {
             if (symbol.flags & SymbolFlags.Transient) return <TransientSymbol>symbol;
-            let id = getSymbolId(symbol);
+            const id = getSymbolId(symbol);
             return symbolLinks[id] || (symbolLinks[id] = {});
         }
 
         function getNodeLinks(node: Node): NodeLinks {
-            let nodeId = getNodeId(node);
+            const nodeId = getNodeId(node);
             return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
         }
 
@@ -367,13 +369,13 @@ namespace ts {
 
         function getSymbol(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol {
             if (meaning && hasProperty(symbols, name)) {
-                let symbol = symbols[name];
+                const symbol = symbols[name];
                 Debug.assert((symbol.flags & SymbolFlags.Instantiated) === 0, "Should never get an instantiated symbol here.");
                 if (symbol.flags & meaning) {
                     return symbol;
                 }
                 if (symbol.flags & SymbolFlags.Alias) {
-                    let target = resolveAlias(symbol);
+                    const target = resolveAlias(symbol);
                     // Unknown symbol means an error occurred in alias resolution, treat it as positive answer to avoid cascading errors
                     if (target === unknownSymbol || target.flags & meaning) {
                         return symbol;
@@ -419,7 +421,7 @@ namespace ts {
                 else if (declaration.parent.parent.kind === SyntaxKind.ForOfStatement ||
                     declaration.parent.parent.kind === SyntaxKind.ForInStatement) {
                     // ForIn/ForOf case - use site should not be used in expression part
-                    let expression = (<ForInStatement | ForOfStatement>declaration.parent.parent).expression;
+                    const expression = (<ForInStatement | ForOfStatement>declaration.parent.parent).expression;
                     return isSameScopeDescendentOf(usage, expression, container);
                 }
             }
@@ -458,7 +460,7 @@ namespace ts {
             let result: Symbol;
             let lastLocation: Node;
             let propertyWithInvalidInitializer: Node;
-            let errorLocation = location;
+            const errorLocation = location;
             let grandparent: Node;
 
             loop: while (location) {
@@ -480,7 +482,7 @@ namespace ts {
                     case SyntaxKind.SourceFile:
                         if (!isExternalModule(<SourceFile>location)) break;
                     case SyntaxKind.ModuleDeclaration:
-                        let moduleExports = getSymbolOfNode(location).exports;
+                        const moduleExports = getSymbolOfNode(location).exports;
                         if (location.kind === SyntaxKind.SourceFile ||
                             (location.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>location).name.kind === SyntaxKind.StringLiteral)) {
 
@@ -502,7 +504,7 @@ namespace ts {
                             }
 
                             result = moduleExports["default"];
-                            let localSymbol = getLocalSymbolForExportDefault(result);
+                            const localSymbol = getLocalSymbolForExportDefault(result);
                             if (result && localSymbol && (result.flags & meaning) && localSymbol.name === name) {
                                 break loop;
                             }
@@ -527,7 +529,7 @@ namespace ts {
                         // by the same name as a constructor parameter or local variable are inaccessible
                         // in initializer expressions for instance member variables.
                         if (isClassLike(location.parent) && !(location.flags & NodeFlags.Static)) {
-                            let ctor = findConstructorDeclaration(<ClassLikeDeclaration>location.parent);
+                            const ctor = findConstructorDeclaration(<ClassLikeDeclaration>location.parent);
                             if (ctor && ctor.locals) {
                                 if (getSymbol(ctor.locals, name, meaning & SymbolFlags.Value)) {
                                     // Remember the property node, it will be used later to report appropriate error
@@ -550,7 +552,7 @@ namespace ts {
                             break loop;
                         }
                         if (location.kind === SyntaxKind.ClassExpression && meaning & SymbolFlags.Class) {
-                            let className = (<ClassExpression>location).name;
+                            const className = (<ClassExpression>location).name;
                             if (className && name === className.text) {
                                 result = location.symbol;
                                 break loop;
@@ -595,7 +597,7 @@ namespace ts {
                         }
 
                         if (meaning & SymbolFlags.Function) {
-                            let functionName = (<FunctionExpression>location).name;
+                            const functionName = (<FunctionExpression>location).name;
                             if (functionName && name === functionName.text) {
                                 result = location.symbol;
                                 break loop;
@@ -645,7 +647,7 @@ namespace ts {
                 if (propertyWithInvalidInitializer) {
                     // We have a match, but the reference occurred within a property initializer and the identifier also binds
                     // to a local variable in the constructor where the code will be emitted.
-                    let propertyName = (<PropertyDeclaration>propertyWithInvalidInitializer).name;
+                    const propertyName = (<PropertyDeclaration>propertyWithInvalidInitializer).name;
                     error(errorLocation, Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor,
                         declarationNameToString(propertyName), typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
                     return undefined;
@@ -657,7 +659,7 @@ namespace ts {
                 //          declare module foo {
                 //              interface bar {}
                 //          }
-                //      let foo/*1*/: foo/*2*/.bar;
+                //      const foo/*1*/: foo/*2*/.bar;
                 // The foo at /*1*/ and /*2*/ will share same symbol with two meaning
                 // block - scope variable and namespace module. However, only when we
                 // try to resolve name in /*1*/ which is used in variable position,
@@ -675,7 +677,7 @@ namespace ts {
         function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
             Debug.assert((result.flags & SymbolFlags.BlockScopedVariable) !== 0);
             // Block-scoped variables cannot be used before their definition
-            let declaration = forEach(result.declarations, d => isBlockOrCatchScoped(d) ? d : undefined);
+            const declaration = forEach(result.declarations, d => isBlockOrCatchScoped(d) ? d : undefined);
 
             Debug.assert(declaration !== undefined, "Block-scoped variable declaration is undefined");
 
@@ -725,9 +727,9 @@ namespace ts {
         }
 
         function getTargetOfImportClause(node: ImportClause): Symbol {
-            let moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);
+            const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);
             if (moduleSymbol) {
-                let exportDefaultSymbol = resolveSymbol(moduleSymbol.exports["default"]);
+                const exportDefaultSymbol = resolveSymbol(moduleSymbol.exports["default"]);
                 if (!exportDefaultSymbol) {
                     error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
                 }
@@ -736,13 +738,13 @@ namespace ts {
         }
 
         function getTargetOfNamespaceImport(node: NamespaceImport): Symbol {
-            let moduleSpecifier = (<ImportDeclaration>node.parent.parent).moduleSpecifier;
+            const moduleSpecifier = (<ImportDeclaration>node.parent.parent).moduleSpecifier;
             return resolveESModuleSymbol(resolveExternalModuleName(node, moduleSpecifier), moduleSpecifier);
         }
 
         function getMemberOfModuleVariable(moduleSymbol: Symbol, name: string): Symbol {
             if (moduleSymbol.flags & SymbolFlags.Variable) {
-                let typeAnnotation = (<VariableDeclaration>moduleSymbol.valueDeclaration).type;
+                const typeAnnotation = (<VariableDeclaration>moduleSymbol.valueDeclaration).type;
                 if (typeAnnotation) {
                     return getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name);
                 }
@@ -771,7 +773,7 @@ namespace ts {
             if (valueSymbol.flags & (SymbolFlags.Type | SymbolFlags.Namespace)) {
                 return valueSymbol;
             }
-            let result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
+            const result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.name);
             result.declarations = concatenate(valueSymbol.declarations, typeSymbol.declarations);
             result.parent = valueSymbol.parent || typeSymbol.parent;
             if (valueSymbol.valueDeclaration) result.valueDeclaration = valueSymbol.valueDeclaration;
@@ -782,7 +784,7 @@ namespace ts {
 
         function getExportOfModule(symbol: Symbol, name: string): Symbol {
             if (symbol.flags & SymbolFlags.Module) {
-                let exports = getExportsOfSymbol(symbol);
+                const exports = getExportsOfSymbol(symbol);
                 if (hasProperty(exports, name)) {
                     return resolveSymbol(exports[name]);
                 }
@@ -791,7 +793,7 @@ namespace ts {
 
         function getPropertyOfVariable(symbol: Symbol, name: string): Symbol {
             if (symbol.flags & SymbolFlags.Variable) {
-                let typeAnnotation = (<VariableDeclaration>symbol.valueDeclaration).type;
+                const typeAnnotation = (<VariableDeclaration>symbol.valueDeclaration).type;
                 if (typeAnnotation) {
                     return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
                 }
@@ -799,14 +801,14 @@ namespace ts {
         }
 
         function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration, specifier: ImportOrExportSpecifier): Symbol {
-            let moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
-            let targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier);
+            const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
+            const targetSymbol = resolveESModuleSymbol(moduleSymbol, node.moduleSpecifier);
             if (targetSymbol) {
-                let name = specifier.propertyName || specifier.name;
+                const name = specifier.propertyName || specifier.name;
                 if (name.text) {
-                    let symbolFromModule = getExportOfModule(targetSymbol, name.text);
-                    let symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);
-                    let symbol = symbolFromModule && symbolFromVariable ?
+                    const symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    const symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);
+                    const symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
                         symbolFromModule || symbolFromVariable;
                     if (!symbol) {
@@ -854,11 +856,11 @@ namespace ts {
 
         function resolveAlias(symbol: Symbol): Symbol {
             Debug.assert((symbol.flags & SymbolFlags.Alias) !== 0, "Should only get Alias here.");
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.target) {
                 links.target = resolvingSymbol;
-                let node = getDeclarationOfAliasSymbol(symbol);
-                let target = getTargetOfAliasDeclaration(node);
+                const node = getDeclarationOfAliasSymbol(symbol);
+                const target = getTargetOfAliasDeclaration(node);
                 if (links.target === resolvingSymbol) {
                     links.target = target || unknownSymbol;
                 }
@@ -873,10 +875,10 @@ namespace ts {
         }
 
         function markExportAsReferenced(node: ImportEqualsDeclaration | ExportAssignment | ExportSpecifier) {
-            let symbol = getSymbolOfNode(node);
-            let target = resolveAlias(symbol);
+            const symbol = getSymbolOfNode(node);
+            const target = resolveAlias(symbol);
             if (target) {
-                let markAlias =
+                const markAlias =
                     (target === unknownSymbol && compilerOptions.isolatedModules) ||
                     (target !== unknownSymbol && (target.flags & SymbolFlags.Value) && !isConstEnumOrConstEnumOnlyModule(target));
 
@@ -890,10 +892,10 @@ namespace ts {
         // we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of
         // the alias as an expression (which recursively takes us back here if the target references another alias).
         function markAliasSymbolAsReferenced(symbol: Symbol) {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.referenced) {
                 links.referenced = true;
-                let node = getDeclarationOfAliasSymbol(symbol);
+                const node = getDeclarationOfAliasSymbol(symbol);
                 if (node.kind === SyntaxKind.ExportAssignment) {
                     // export default <symbol>
                     checkExpressionCached((<ExportAssignment>node).expression);
@@ -948,7 +950,7 @@ namespace ts {
 
             let symbol: Symbol;
             if (name.kind === SyntaxKind.Identifier) {
-                let message = meaning === SymbolFlags.Namespace ? Diagnostics.Cannot_find_namespace_0 : Diagnostics.Cannot_find_name_0;
+                const message = meaning === SymbolFlags.Namespace ? Diagnostics.Cannot_find_namespace_0 : Diagnostics.Cannot_find_name_0;
 
                 symbol = resolveName(name, (<Identifier>name).text, meaning, ignoreErrors ? undefined : message, <Identifier>name);
                 if (!symbol) {
@@ -956,10 +958,10 @@ namespace ts {
                 }
             }
             else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
-                let left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
-                let right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
+                const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
+                const right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
 
-                let namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors);
+                const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors);
                 if (!namespace || namespace === unknownSymbol || nodeIsMissing(right)) {
                     return undefined;
                 }
@@ -983,26 +985,26 @@ namespace ts {
                 return;
             }
 
-            let moduleReferenceLiteral = <LiteralExpression>moduleReferenceExpression;
-            let searchPath = getDirectoryPath(getSourceFile(location).fileName);
+            const moduleReferenceLiteral = <LiteralExpression>moduleReferenceExpression;
+            const searchPath = getDirectoryPath(getSourceFile(location).fileName);
 
             // Module names are escaped in our symbol table.  However, string literal values aren't.
             // Escape the name in the "require(...)" clause to ensure we find the right symbol.
-            let moduleName = escapeIdentifier(moduleReferenceLiteral.text);
+            const moduleName = escapeIdentifier(moduleReferenceLiteral.text);
 
             if (moduleName === undefined) {
                 return;
             }
-            let isRelative = isExternalModuleNameRelative(moduleName);
+            const isRelative = isExternalModuleNameRelative(moduleName);
             if (!isRelative) {
-                let symbol = getSymbol(globals, "\"" + moduleName + "\"", SymbolFlags.ValueModule);
+                const symbol = getSymbol(globals, "\"" + moduleName + "\"", SymbolFlags.ValueModule);
                 if (symbol) {
                     return symbol;
                 }
             }
 
-            let resolvedModule = getResolvedModule(getSourceFile(location), moduleReferenceLiteral.text);
-            let sourceFile = resolvedModule && host.getSourceFile(resolvedModule.resolvedFileName);
+            const resolvedModule = getResolvedModule(getSourceFile(location), moduleReferenceLiteral.text);
+            const sourceFile = resolvedModule && host.getSourceFile(resolvedModule.resolvedFileName);
             if (sourceFile) {
                 if (sourceFile.symbol) {
                     return sourceFile.symbol;
@@ -1044,12 +1046,12 @@ namespace ts {
         }
 
         function getExportsOfModule(moduleSymbol: Symbol): SymbolTable {
-            let links = getSymbolLinks(moduleSymbol);
+            const links = getSymbolLinks(moduleSymbol);
             return links.resolvedExports || (links.resolvedExports = getExportsForModule(moduleSymbol));
         }
 
         function extendExportSymbols(target: SymbolTable, source: SymbolTable) {
-            for (let id in source) {
+            for (const id in source) {
                 if (id !== "default" && !hasProperty(target, id)) {
                     target[id] = source[id];
                 }
@@ -1058,7 +1060,7 @@ namespace ts {
 
         function getExportsForModule(moduleSymbol: Symbol): SymbolTable {
             let result: SymbolTable;
-            let visitedSymbols: Symbol[] = [];
+            const visitedSymbols: Symbol[] = [];
             visit(moduleSymbol);
             return result || moduleSymbol.exports;
 
@@ -1074,9 +1076,9 @@ namespace ts {
                         extendExportSymbols(result, symbol.exports);
                     }
                     // All export * declarations are collected in an __export symbol by the binder
-                    let exportStars = symbol.exports["__export"];
+                    const exportStars = symbol.exports["__export"];
                     if (exportStars) {
-                        for (let node of exportStars.declarations) {
+                        for (const node of exportStars.declarations) {
                             visit(resolveExternalModuleName(node, (<ExportDeclaration>node).moduleSpecifier));
                         }
                     }
@@ -1124,8 +1126,8 @@ namespace ts {
         }
 
         function findConstructorDeclaration(node: ClassLikeDeclaration): ConstructorDeclaration {
-            let members = node.members;
-            for (let member of members) {
+            const members = node.members;
+            for (const member of members) {
                 if (member.kind === SyntaxKind.Constructor && nodeIsPresent((<ConstructorDeclaration>member).body)) {
                     return <ConstructorDeclaration>member;
                 }
@@ -1133,19 +1135,19 @@ namespace ts {
         }
 
         function createType(flags: TypeFlags): Type {
-            let result = new Type(checker, flags);
+            const result = new Type(checker, flags);
             result.id = typeCount++;
             return result;
         }
 
         function createIntrinsicType(kind: TypeFlags, intrinsicName: string): IntrinsicType {
-            let type = <IntrinsicType>createType(kind);
+            const type = <IntrinsicType>createType(kind);
             type.intrinsicName = intrinsicName;
             return type;
         }
 
         function createObjectType(kind: TypeFlags, symbol?: Symbol): ObjectType {
-            let type = <ObjectType>createType(kind);
+            const type = <ObjectType>createType(kind);
             type.symbol = symbol;
             return type;
         }
@@ -1163,11 +1165,11 @@ namespace ts {
 
         function getNamedMembers(members: SymbolTable): Symbol[] {
             let result: Symbol[];
-            for (let id in members) {
+            for (const id in members) {
                 if (hasProperty(members, id)) {
                     if (!isReservedMemberName(id)) {
                         if (!result) result = [];
-                        let symbol = members[id];
+                        const symbol = members[id];
                         if (symbolIsValue(symbol)) {
                             result.push(symbol);
                         }
@@ -1237,7 +1239,7 @@ namespace ts {
                     }
 
                     // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too
-                    let accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing);
+                    const accessibleParent = getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing);
                     return !!accessibleParent;
                 }
 
@@ -1265,14 +1267,14 @@ namespace ts {
                             // Is this external alias, then use it to name
                             ts.forEach(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) {
 
-                            let resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
+                            const resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
                             if (isAccessible(symbolFromSymbolTable, resolveAlias(symbolFromSymbolTable))) {
                                 return [symbolFromSymbolTable];
                             }
 
                             // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain
                             // but only if the symbolFromSymbolTable can be qualified
-                            let accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
+                            const accessibleSymbolsFromExports = resolvedImportedSymbol.exports ? getAccessibleSymbolChainFromSymbolTable(resolvedImportedSymbol.exports) : undefined;
                             if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
                                 return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
                             }
@@ -1317,13 +1319,13 @@ namespace ts {
 
         function isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult {
             if (symbol && enclosingDeclaration && !(symbol.flags & SymbolFlags.TypeParameter)) {
-                let initialSymbol = symbol;
+                const initialSymbol = symbol;
                 let meaningToLook = meaning;
                 while (symbol) {
                     // Symbol is accessible if it by itself is accessible
-                    let accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
+                    const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
                     if (accessibleSymbolChain) {
-                        let hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
+                        const hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0]);
                         if (!hasAccessibleDeclarations) {
                             return <SymbolAccessiblityResult>{
                                 accessibility: SymbolAccessibility.NotAccessible,
@@ -1341,7 +1343,7 @@ namespace ts {
                     //     export class c {
                     //     }
                     // }
-                    // let x: typeof m.c
+                    // const x: typeof m.c
                     // In the above example when we start with checking if typeof m.c symbol is accessible,
                     // we are going to see if c can be accessed in scope directly.
                     // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible
@@ -1352,9 +1354,9 @@ namespace ts {
 
                 // This could be a symbol that is not exported in the external module
                 // or it could be a symbol from different external module that is not aliased and hence cannot be named
-                let symbolExternalModule = forEach(initialSymbol.declarations, getExternalModuleContainer);
+                const symbolExternalModule = forEach(initialSymbol.declarations, getExternalModuleContainer);
                 if (symbolExternalModule) {
-                    let enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
+                    const enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
                     if (symbolExternalModule !== enclosingExternalModule) {
                         // name from different external module that is not visible
                         return {
@@ -1400,7 +1402,7 @@ namespace ts {
                     // Mark the unexported alias as visible if its parent is visible
                     // because these kind of aliases can be used to name types in declaration file
 
-                    let anyImportSyntax = getAnyImportSyntax(declaration);
+                    const anyImportSyntax = getAnyImportSyntax(declaration);
                     if (anyImportSyntax &&
                         !(anyImportSyntax.flags & NodeFlags.Export) && // import clause without export
                         isDeclarationVisible(<Declaration>anyImportSyntax.parent)) {
@@ -1442,8 +1444,8 @@ namespace ts {
                 meaning = SymbolFlags.Type;
             }
 
-            let firstIdentifier = getFirstIdentifier(entityName);
-            let symbol = resolveName(enclosingDeclaration, (<Identifier>firstIdentifier).text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
+            const firstIdentifier = getFirstIdentifier(entityName);
+            const symbol = resolveName(enclosingDeclaration, (<Identifier>firstIdentifier).text, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
 
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol)) || <SymbolVisibilityResult>{
@@ -1466,30 +1468,30 @@ namespace ts {
         }
 
         function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string {
-            let writer = getSingleLineStringWriter();
+            const writer = getSingleLineStringWriter();
             getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning);
-            let result = writer.string();
+            const result = writer.string();
             releaseStringWriter(writer);
 
             return result;
         }
 
         function signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
-            let writer = getSingleLineStringWriter();
+            const writer = getSingleLineStringWriter();
             getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);
-            let result = writer.string();
+            const result = writer.string();
             releaseStringWriter(writer);
 
             return result;
         }
 
         function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
-            let writer = getSingleLineStringWriter();
+            const writer = getSingleLineStringWriter();
             getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
             let result = writer.string();
             releaseStringWriter(writer);
 
-            let maxLength = compilerOptions.noErrorTruncation || flags & TypeFormatFlags.NoTruncation ? undefined : 100;
+            const maxLength = compilerOptions.noErrorTruncation || flags & TypeFormatFlags.NoTruncation ? undefined : 100;
             if (maxLength && result.length >= maxLength) {
                 result = result.substr(0, maxLength - "...".length) + "...";
             }
@@ -1513,7 +1515,7 @@ namespace ts {
 
             function getNameOfSymbol(symbol: Symbol): string {
                 if (symbol.declarations && symbol.declarations.length) {
-                    let declaration = symbol.declarations[0];
+                    const declaration = symbol.declarations[0];
                     if (declaration.name) {
                         return declarationNameToString(declaration.name);
                     }
@@ -1560,7 +1562,7 @@ namespace ts {
                     appendSymbolNameOnly(symbol, writer);
                 }
 
-                // Let the writer know we just wrote out a symbol.  The declaration emitter writer uses
+                // const the writer know we just wrote out a symbol.  The declaration emitter writer uses
                 // this to determine if an import it has previously seen (and not written out) needs
                 // to be written to the file once the walk of the tree is complete.
                 //
@@ -1570,7 +1572,7 @@ namespace ts {
                 writer.trackSymbol(symbol, enclosingDeclaration, meaning);
                 function walkSymbol(symbol: Symbol, meaning: SymbolFlags): void {
                     if (symbol) {
-                        let accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
+                        const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
 
                         if (!accessibleSymbolChain ||
                             needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
@@ -1582,7 +1584,7 @@ namespace ts {
                         }
 
                         if (accessibleSymbolChain) {
-                            for (let accessibleSymbol of accessibleSymbolChain) {
+                            for (const accessibleSymbol of accessibleSymbolChain) {
                                 appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
                             }
                         }
@@ -1605,8 +1607,8 @@ namespace ts {
                 // Get qualified name if the symbol is not a type parameter
                 // and there is an enclosing declaration or we specifically
                 // asked for it
-                let isTypeParameter = symbol.flags & SymbolFlags.TypeParameter;
-                let typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags;
+                const isTypeParameter = symbol.flags & SymbolFlags.TypeParameter;
+                const typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags;
                 if (!isTypeParameter && (enclosingDeclaration || typeFormatFlag)) {
                     walkSymbol(symbol, meaning);
                     return;
@@ -1616,7 +1618,7 @@ namespace ts {
             }
 
             function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, symbolStack?: Symbol[]) {
-                let globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
+                const globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike;
                 let inObjectTypeLiteral = false;
                 return writeType(type, globalFlags);
 
@@ -1695,7 +1697,7 @@ namespace ts {
                 }
 
                 function writeTypeReference(type: TypeReference, flags: TypeFormatFlags) {
-                    let typeArguments = type.typeArguments || emptyArray;
+                    const typeArguments = type.typeArguments || emptyArray;
                     if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
                         writeType(typeArguments[0], TypeFormatFlags.InElementType);
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
@@ -1705,14 +1707,14 @@ namespace ts {
                         // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
                         // for outer type parameters, and f and g are the respective declaring containers of those
                         // type parameters.
-                        let outerTypeParameters = type.target.outerTypeParameters;
+                        const outerTypeParameters = type.target.outerTypeParameters;
                         let i = 0;
                         if (outerTypeParameters) {
-                            let length = outerTypeParameters.length;
+                            const length = outerTypeParameters.length;
                             while (i < length) {
                                 // Find group of type arguments for type parameters with the same declaring container.
-                                let start = i;
-                                let parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
+                                const start = i;
+                                const parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
                                 do {
                                     i++;
                                 } while (i < length && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent);
@@ -1724,7 +1726,7 @@ namespace ts {
                                 }
                             }
                         }
-                        let typeParameterCount = (type.target.typeParameters || emptyArray).length;
+                        const typeParameterCount = (type.target.typeParameters || emptyArray).length;
                         writeSymbolTypeReference(type.symbol, typeArguments, i, typeParameterCount, flags);
                     }
                 }
@@ -1746,7 +1748,7 @@ namespace ts {
                 }
 
                 function writeAnonymousType(type: ObjectType, flags: TypeFormatFlags) {
-                    let symbol = type.symbol;
+                    const symbol = type.symbol;
                     if (symbol) {
                         // Always use 'typeof T' for type of class, enum, and module objects
                         if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
@@ -1757,7 +1759,7 @@ namespace ts {
                         }
                         else if (contains(symbolStack, symbol)) {
                             // If type is an anonymous type literal in a type alias declaration, use type alias name
-                            let typeAlias = getTypeAliasForTypeLiteral(type);
+                            const typeAlias = getTypeAliasForTypeLiteral(type);
                             if (typeAlias) {
                                 // The specified symbol flags need to be reinterpreted as type flags
                                 buildSymbolDisplay(typeAlias, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags);
@@ -1784,9 +1786,9 @@ namespace ts {
                     }
 
                     function shouldWriteTypeOfFunctionSymbol() {
-                        let isStaticMethodSymbol = !!(symbol.flags & SymbolFlags.Method &&  // typeof static method
+                        const isStaticMethodSymbol = !!(symbol.flags & SymbolFlags.Method &&  // typeof static method
                             forEach(symbol.declarations, declaration => declaration.flags & NodeFlags.Static));
-                        let isNonLocalFunctionSymbol = !!(symbol.flags & SymbolFlags.Function) &&
+                        const isNonLocalFunctionSymbol = !!(symbol.flags & SymbolFlags.Function) &&
                             (symbol.parent || // is exported function symbol
                                 forEach(symbol.declarations, declaration =>
                                     declaration.parent.kind === SyntaxKind.SourceFile || declaration.parent.kind === SyntaxKind.ModuleBlock));
@@ -1805,7 +1807,7 @@ namespace ts {
                 }
 
                 function getIndexerParameterName(type: ObjectType, indexKind: IndexKind, fallbackName: string): string {
-                    let declaration = <SignatureDeclaration>getIndexDeclarationOfSymbol(type.symbol, indexKind);
+                    const declaration = <SignatureDeclaration>getIndexDeclarationOfSymbol(type.symbol, indexKind);
                     if (!declaration) {
                         // declaration might not be found if indexer was added from the contextual type.
                         // in this case use fallback name
@@ -1816,7 +1818,7 @@ namespace ts {
                 }
 
                 function writeLiteralType(type: ObjectType, flags: TypeFormatFlags) {
-                    let resolved = resolveStructuredTypeMembers(type);
+                    const resolved = resolveStructuredTypeMembers(type);
                     if (!resolved.properties.length && !resolved.stringIndexType && !resolved.numberIndexType) {
                         if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
                             writePunctuation(writer, SyntaxKind.OpenBraceToken);
@@ -1848,17 +1850,17 @@ namespace ts {
                         }
                     }
 
-                    let saveInObjectTypeLiteral = inObjectTypeLiteral;
+                    const saveInObjectTypeLiteral = inObjectTypeLiteral;
                     inObjectTypeLiteral = true;
                     writePunctuation(writer, SyntaxKind.OpenBraceToken);
                     writer.writeLine();
                     writer.increaseIndent();
-                    for (let signature of resolved.callSignatures) {
+                    for (const signature of resolved.callSignatures) {
                         buildSignatureDisplay(signature, writer, enclosingDeclaration, globalFlagsToPass, symbolStack);
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
-                    for (let signature of resolved.constructSignatures) {
+                    for (const signature of resolved.constructSignatures) {
                         writeKeyword(writer, SyntaxKind.NewKeyword);
                         writeSpace(writer);
 
@@ -1894,11 +1896,11 @@ namespace ts {
                         writePunctuation(writer, SyntaxKind.SemicolonToken);
                         writer.writeLine();
                     }
-                    for (let p of resolved.properties) {
-                        let t = getTypeOfSymbol(p);
+                    for (const p of resolved.properties) {
+                        const t = getTypeOfSymbol(p);
                         if (p.flags & (SymbolFlags.Function | SymbolFlags.Method) && !getPropertiesOfObjectType(t).length) {
-                            let signatures = getSignaturesOfType(t, SignatureKind.Call);
-                            for (let signature of signatures) {
+                            const signatures = getSignaturesOfType(t, SignatureKind.Call);
+                            for (const signature of signatures) {
                                 buildSymbolDisplay(p, writer);
                                 if (p.flags & SymbolFlags.Optional) {
                                     writePunctuation(writer, SyntaxKind.QuestionToken);
@@ -1927,7 +1929,7 @@ namespace ts {
             }
 
             function buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) {
-                let targetSymbol = getTargetSymbol(symbol);
+                const targetSymbol = getTargetSymbol(symbol);
                 if (targetSymbol.flags & SymbolFlags.Class || targetSymbol.flags & SymbolFlags.Interface || targetSymbol.flags & SymbolFlags.TypeAlias) {
                     buildDisplayForTypeParametersAndDelimiters(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), writer, enclosingDeclaraiton, flags);
                 }
@@ -1935,7 +1937,7 @@ namespace ts {
 
             function buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
                 appendSymbolNameOnly(tp.symbol, writer);
-                let constraint = getConstraintOfTypeParameter(tp);
+                const constraint = getConstraintOfTypeParameter(tp);
                 if (constraint) {
                     writeSpace(writer);
                     writeKeyword(writer, SyntaxKind.ExtendsKeyword);
@@ -1945,7 +1947,7 @@ namespace ts {
             }
 
             function buildParameterDisplay(p: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
-                let parameterNode = <ParameterDeclaration>p.valueDeclaration;
+                const parameterNode = <ParameterDeclaration>p.valueDeclaration;
                 if (isRestParameter(parameterNode)) {
                     writePunctuation(writer, SyntaxKind.DotDotDotToken);
                 }
@@ -2067,14 +2069,14 @@ namespace ts {
 
             function isUsedInExportAssignment(node: Node) {
                 // Get source File and see if it is external module and has export assigned symbol
-                let externalModule = getContainingExternalModule(node);
+                const externalModule = getContainingExternalModule(node);
                 let exportAssignmentSymbol: Symbol;
                 let resolvedExportSymbol: Symbol;
                 if (externalModule) {
                     // This is export assigned symbol node
-                    let externalModuleSymbol = getSymbolOfNode(externalModule);
+                    const externalModuleSymbol = getSymbolOfNode(externalModule);
                     exportAssignmentSymbol = getExportAssignmentSymbol(externalModuleSymbol);
-                    let symbolOfNode = getSymbolOfNode(node);
+                    const symbolOfNode = getSymbolOfNode(node);
                     if (isSymbolUsedInExportAssignment(symbolOfNode)) {
                         return true;
                     }
@@ -2129,7 +2131,7 @@ namespace ts {
                     case SyntaxKind.FunctionDeclaration:
                     case SyntaxKind.EnumDeclaration:
                     case SyntaxKind.ImportEqualsDeclaration:
-                        let parent = getDeclarationContainer(node);
+                        const parent = getDeclarationContainer(node);
                         // If the node is not exported or it is not ambient module element (except import declaration)
                         if (!(getCombinedNodeFlags(node) & NodeFlags.Export) &&
                             !(node.kind !== SyntaxKind.ImportEqualsDeclaration && parent.kind !== SyntaxKind.SourceFile && isInAmbientContext(parent))) {
@@ -2148,7 +2150,7 @@ namespace ts {
                             // Private/protected properties/methods are not visible
                             return false;
                         }
-                    // Public properties/methods are visible if its parents are visible, so let it fall into next case statement
+                    // Public properties/methods are visible if its parents are visible, so const it fall into next case statement
 
                     case SyntaxKind.Constructor:
                     case SyntaxKind.ConstructSignature:
@@ -2190,7 +2192,7 @@ namespace ts {
             }
 
             if (node) {
-                let links = getNodeLinks(node);
+                const links = getNodeLinks(node);
                 if (links.isVisible === undefined) {
                     links.isVisible = !!determineIfDeclarationIsVisible();
                 }
@@ -2204,12 +2206,12 @@ namespace ts {
                 exportSymbol = resolveName(node.parent, node.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias, Diagnostics.Cannot_find_name_0, node);
             }
             else if (node.parent.kind === SyntaxKind.ExportSpecifier) {
-                let exportSpecifier = <ExportSpecifier>node.parent;
+                const exportSpecifier = <ExportSpecifier>node.parent;
                 exportSymbol = (<ExportDeclaration>exportSpecifier.parent.parent).moduleSpecifier ?
                     getExternalModuleMember(<ExportDeclaration>exportSpecifier.parent.parent, exportSpecifier) :
                     resolveEntityName(exportSpecifier.propertyName || exportSpecifier.name, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
-            let result: Node[] = [];
+            const result: Node[] = [];
             if (exportSymbol) {
                 buildVisibleNodeList(exportSymbol.declarations);
             }
@@ -2218,16 +2220,16 @@ namespace ts {
             function buildVisibleNodeList(declarations: Declaration[]) {
                 forEach(declarations, declaration => {
                     getNodeLinks(declaration).isVisible = true;
-                    let resultNode = getAnyImportSyntax(declaration) || declaration;
+                    const resultNode = getAnyImportSyntax(declaration) || declaration;
                     if (!contains(result, resultNode)) {
                         result.push(resultNode);
                     }
 
                     if (isInternalModuleImportEqualsDeclaration(declaration)) {
                         // Add the referenced top container visible
-                        let internalModuleReference = <Identifier | QualifiedName>(<ImportEqualsDeclaration>declaration).moduleReference;
-                        let firstIdentifier = getFirstIdentifier(internalModuleReference);
-                        let importSymbol = resolveName(declaration, firstIdentifier.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace,
+                        const internalModuleReference = <Identifier | QualifiedName>(<ImportEqualsDeclaration>declaration).moduleReference;
+                        const firstIdentifier = getFirstIdentifier(internalModuleReference);
+                        const importSymbol = resolveName(declaration, firstIdentifier.text, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace,
                             Diagnostics.Cannot_find_name_0, firstIdentifier);
                         buildVisibleNodeList(importSymbol.declarations);
                     }
@@ -2247,10 +2249,10 @@ namespace ts {
          * @param propertyName The property name that should be used to query the target for its type
          */
         function pushTypeResolution(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): boolean {
-            let resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
+            const resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
             if (resolutionCycleStartIndex >= 0) {
                 // A cycle was found
-                let { length } = resolutionTargets;
+                const { length } = resolutionTargets;
                 for (let i = resolutionCycleStartIndex; i < length; i++) {
                     resolutionResults[i] = false;
                 }
@@ -2314,13 +2316,13 @@ namespace ts {
             // Every class automatically contains a static property member named 'prototype',
             // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter.
             // It is an error to explicitly declare a static property member with the name 'prototype'.
-            let classType = <InterfaceType>getDeclaredTypeOfSymbol(prototype.parent);
+            const classType = <InterfaceType>getDeclaredTypeOfSymbol(prototype.parent);
             return classType.typeParameters ? createTypeReference(<GenericType>classType, map(classType.typeParameters, _ => anyType)) : classType;
         }
 
         // Return the type of the given property in the given type, or undefined if no such property exists
         function getTypeOfPropertyOfType(type: Type, name: string): Type {
-            let prop = getPropertyOfType(type, name);
+            const prop = getPropertyOfType(type, name);
             return prop ? getTypeOfSymbol(prop) : undefined;
         }
 
@@ -2331,14 +2333,14 @@ namespace ts {
         // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been
         // assigned by contextual typing.
         function getTypeForBindingElementParent(node: VariableLikeDeclaration) {
-            let symbol = getSymbolOfNode(node);
+            const symbol = getSymbolOfNode(node);
             return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node);
         }
 
         // Return the inferred type for a binding element
         function getTypeForBindingElement(declaration: BindingElement): Type {
-            let pattern = <BindingPattern>declaration.parent;
-            let parentType = getTypeForBindingElementParent(<VariableLikeDeclaration>pattern.parent);
+            const pattern = <BindingPattern>declaration.parent;
+            const parentType = getTypeForBindingElementParent(<VariableLikeDeclaration>pattern.parent);
             // If parent has the unknown (error) type, then so does this binding element
             if (parentType === unknownType) {
                 return unknownType;
@@ -2356,7 +2358,7 @@ namespace ts {
             let type: Type;
             if (pattern.kind === SyntaxKind.ObjectBindingPattern) {
                 // Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form)
-                let name = declaration.propertyName || <Identifier>declaration.name;
+                const name = declaration.propertyName || <Identifier>declaration.name;
                 // Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature,
                 // or otherwise the type of the string index signature.
                 type = getTypeOfPropertyOfType(parentType, name.text) ||
@@ -2371,10 +2373,10 @@ namespace ts {
                 // This elementType will be used if the specific property corresponding to this index is not
                 // present (aka the tuple element property). This call also checks that the parentType is in
                 // fact an iterable or array (depending on target language).
-                let elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false);
+                const elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false);
                 if (!declaration.dotDotDotToken) {
                     // Use specific property type when parent is a tuple or numeric index type when parent is an array
-                    let propName = "" + indexOf(pattern.elements, declaration);
+                    const propName = "" + indexOf(pattern.elements, declaration);
                     type = isTupleLikeType(parentType)
                         ? getTypeOfPropertyOfType(parentType, propName)
                         : elementType;
@@ -2421,16 +2423,16 @@ namespace ts {
             }
 
             if (declaration.kind === SyntaxKind.Parameter) {
-                let func = <FunctionLikeDeclaration>declaration.parent;
+                const func = <FunctionLikeDeclaration>declaration.parent;
                 // For a parameter of a set accessor, use the type of the get accessor if one is present
                 if (func.kind === SyntaxKind.SetAccessor && !hasDynamicName(func)) {
-                    let getter = <AccessorDeclaration>getDeclarationOfKind(declaration.parent.symbol, SyntaxKind.GetAccessor);
+                    const getter = <AccessorDeclaration>getDeclarationOfKind(declaration.parent.symbol, SyntaxKind.GetAccessor);
                     if (getter) {
                         return getReturnTypeOfSignature(getSignatureFromDeclaration(getter));
                     }
                 }
                 // Use contextual parameter type if one is available
-                let type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                const type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
                 if (type) {
                     return type;
                 }
@@ -2470,16 +2472,16 @@ namespace ts {
 
         // Return the type implied by an object binding pattern
         function getTypeFromObjectBindingPattern(pattern: BindingPattern, includePatternInType: boolean): Type {
-            let members: SymbolTable = {};
+            const members: SymbolTable = {};
             forEach(pattern.elements, e => {
-                let flags = SymbolFlags.Property | SymbolFlags.Transient | (e.initializer ? SymbolFlags.Optional : 0);
-                let name = e.propertyName || <Identifier>e.name;
-                let symbol = <TransientSymbol>createSymbol(flags, name.text);
+                const flags = SymbolFlags.Property | SymbolFlags.Transient | (e.initializer ? SymbolFlags.Optional : 0);
+                const name = e.propertyName || <Identifier>e.name;
+                const symbol = <TransientSymbol>createSymbol(flags, name.text);
                 symbol.type = getTypeFromBindingElement(e, includePatternInType);
                 symbol.bindingElement = e;
                 members[symbol.name] = symbol;
             });
-            let result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined);
+            const result = createAnonymousType(undefined, members, emptyArray, emptyArray, undefined, undefined);
             if (includePatternInType) {
                 result.pattern = pattern;
             }
@@ -2488,14 +2490,14 @@ namespace ts {
 
         // Return the type implied by an array binding pattern
         function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean): Type {
-            let elements = pattern.elements;
+            const elements = pattern.elements;
             if (elements.length === 0 || elements[elements.length - 1].dotDotDotToken) {
                 return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType;
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
-            let elementTypes = map(elements, e => e.kind === SyntaxKind.OmittedExpression ? anyType : getTypeFromBindingElement(e, includePatternInType));
+            const elementTypes = map(elements, e => e.kind === SyntaxKind.OmittedExpression ? anyType : getTypeFromBindingElement(e, includePatternInType));
             if (includePatternInType) {
-                let result = createNewTupleType(elementTypes);
+                const result = createNewTupleType(elementTypes);
                 result.pattern = pattern;
                 return result;
             }
@@ -2541,7 +2543,7 @@ namespace ts {
 
             // Report implicit any errors unless this is a private property within an ambient declaration
             if (reportErrors && compilerOptions.noImplicitAny) {
-                let root = getRootDeclaration(declaration);
+                const root = getRootDeclaration(declaration);
                 if (!isPrivateWithinAmbient(root) && !(root.kind === SyntaxKind.Parameter && isPrivateWithinAmbient(root.parent))) {
                     reportImplicitAnyError(declaration, type);
                 }
@@ -2550,14 +2552,14 @@ namespace ts {
         }
 
         function getTypeOfVariableOrParameterOrProperty(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.type) {
                 // Handle prototype property
                 if (symbol.flags & SymbolFlags.Prototype) {
                     return links.type = getTypeOfPrototypeProperty(symbol);
                 }
                 // Handle catch clause variables
-                let declaration = symbol.valueDeclaration;
+                const declaration = symbol.valueDeclaration;
                 if (declaration.parent.kind === SyntaxKind.CatchClause) {
                     return links.type = anyType;
                 }
@@ -2597,7 +2599,7 @@ namespace ts {
                     return accessor.type && getTypeFromTypeNode(accessor.type);
                 }
                 else {
-                    let setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor);
+                    const setterTypeAnnotation = getSetAccessorTypeAnnotationNode(accessor);
                     return setterTypeAnnotation && getTypeFromTypeNode(setterTypeAnnotation);
                 }
             }
@@ -2605,22 +2607,22 @@ namespace ts {
         }
 
         function getTypeOfAccessors(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.type) {
                 if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
                     return unknownType;
                 }
-                let getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
-                let setter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
+                const getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
+                const setter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.SetAccessor);
                 let type: Type;
                 // First try to see if the user specified a return type on the get-accessor.
-                let getterReturnType = getAnnotatedAccessorType(getter);
+                const getterReturnType = getAnnotatedAccessorType(getter);
                 if (getterReturnType) {
                     type = getterReturnType;
                 }
                 else {
                     // If the user didn't specify a return type, try to use the set-accessor's parameter type.
-                    let setterParameterType = getAnnotatedAccessorType(setter);
+                    const setterParameterType = getAnnotatedAccessorType(setter);
                     if (setterParameterType) {
                         type = setterParameterType;
                     }
@@ -2641,7 +2643,7 @@ namespace ts {
                 if (!popTypeResolution()) {
                     type = anyType;
                     if (compilerOptions.noImplicitAny) {
-                        let getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
+                        const getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
                         error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
                     }
                 }
@@ -2651,7 +2653,7 @@ namespace ts {
         }
 
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.type) {
                 links.type = createObjectType(TypeFlags.Anonymous, symbol);
             }
@@ -2659,7 +2661,7 @@ namespace ts {
         }
 
         function getTypeOfEnumMember(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.type) {
                 links.type = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
             }
@@ -2667,9 +2669,9 @@ namespace ts {
         }
 
         function getTypeOfAlias(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.type) {
-                let targetSymbol = resolveAlias(symbol);
+                const targetSymbol = resolveAlias(symbol);
 
                 // It only makes sense to get the type of a value symbol. If the result of resolving
                 // the alias is not a value, then it has no type. To get the type associated with a
@@ -2684,7 +2686,7 @@ namespace ts {
         }
 
         function getTypeOfInstantiatedSymbol(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.type) {
                 links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
             }
@@ -2720,7 +2722,7 @@ namespace ts {
         function hasBaseType(type: InterfaceType, checkBase: InterfaceType) {
             return check(type);
             function check(type: InterfaceType): boolean {
-                let target = <InterfaceType>getTargetType(type);
+                const target = <InterfaceType>getTargetType(type);
                 return target === checkBase || forEach(getBaseTypes(target), check);
             }
         }
@@ -2729,8 +2731,8 @@ namespace ts {
         // The function allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set
         // in-place and returns the same array.
         function appendTypeParameters(typeParameters: TypeParameter[], declarations: TypeParameterDeclaration[]): TypeParameter[] {
-            for (let declaration of declarations) {
-                let tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
+            for (const declaration of declarations) {
+                const tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
                 if (!typeParameters) {
                     typeParameters = [tp];
                 }
@@ -2753,7 +2755,7 @@ namespace ts {
                 if (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression ||
                     node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression ||
                     node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.ArrowFunction) {
-                    let declarations = (<ClassLikeDeclaration | FunctionLikeDeclaration>node).typeParameters;
+                    const declarations = (<ClassLikeDeclaration | FunctionLikeDeclaration>node).typeParameters;
                     if (declarations) {
                         return appendTypeParameters(appendOuterTypeParameters(typeParameters, node), declarations);
                     }
@@ -2763,7 +2765,7 @@ namespace ts {
 
         // The outer type parameters are those defined by enclosing generic classes, methods, or functions.
         function getOuterTypeParametersOfClassOrInterface(symbol: Symbol): TypeParameter[] {
-            let declaration = symbol.flags & SymbolFlags.Class ? symbol.valueDeclaration : getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration);
+            const declaration = symbol.flags & SymbolFlags.Class ? symbol.valueDeclaration : getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration);
             return appendOuterTypeParameters(undefined, declaration);
         }
 
@@ -2771,10 +2773,10 @@ namespace ts {
         // interface, or type alias.
         function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol: Symbol): TypeParameter[] {
             let result: TypeParameter[];
-            for (let node of symbol.declarations) {
+            for (const node of symbol.declarations) {
                 if (node.kind === SyntaxKind.InterfaceDeclaration || node.kind === SyntaxKind.ClassDeclaration ||
                     node.kind === SyntaxKind.ClassExpression || node.kind === SyntaxKind.TypeAliasDeclaration) {
-                    let declaration = <InterfaceDeclaration | TypeAliasDeclaration>node;
+                    const declaration = <InterfaceDeclaration | TypeAliasDeclaration>node;
                     if (declaration.typeParameters) {
                         result = appendTypeParameters(result, declaration.typeParameters);
                     }
@@ -2798,7 +2800,7 @@ namespace ts {
         }
 
         function getConstructorsForTypeArguments(type: ObjectType, typeArgumentNodes: TypeNode[]): Signature[] {
-            let typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0;
+            const typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0;
             return filter(getSignaturesOfType(type, SignatureKind.Construct),
                 sig => (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount);
         }
@@ -2806,7 +2808,7 @@ namespace ts {
         function getInstantiatedConstructorsForTypeArguments(type: ObjectType, typeArgumentNodes: TypeNode[]): Signature[] {
             let signatures = getConstructorsForTypeArguments(type, typeArgumentNodes);
             if (typeArgumentNodes) {
-                let typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
+                const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
                 signatures = map(signatures, sig => getSignatureInstantiation(sig, typeArguments));
             }
             return signatures;
@@ -2819,14 +2821,14 @@ namespace ts {
         // an object type with at least one construct signature.
         function getBaseConstructorTypeOfClass(type: InterfaceType): ObjectType {
             if (!type.resolvedBaseConstructorType) {
-                let baseTypeNode = getBaseTypeNodeOfClass(type);
+                const baseTypeNode = getBaseTypeNodeOfClass(type);
                 if (!baseTypeNode) {
                     return type.resolvedBaseConstructorType = undefinedType;
                 }
                 if (!pushTypeResolution(type, TypeSystemPropertyName.ResolvedBaseConstructorType)) {
                     return unknownType;
                 }
-                let baseConstructorType = checkExpression(baseTypeNode.expression);
+                const baseConstructorType = checkExpression(baseTypeNode.expression);
                 if (baseConstructorType.flags & TypeFlags.ObjectType) {
                     // Resolving the members of a class requires us to resolve the base class of that class.
                     // We force resolution here such that we catch circularities now.
@@ -2850,8 +2852,8 @@ namespace ts {
         }
 
         function getBaseTypes(type: InterfaceType): ObjectType[] {
-            let isClass = type.symbol.flags & SymbolFlags.Class;
-            let isInterface = type.symbol.flags & SymbolFlags.Interface;
+            const isClass = type.symbol.flags & SymbolFlags.Class;
+            const isInterface = type.symbol.flags & SymbolFlags.Interface;
             if (!type.resolvedBaseTypes) {
                 if (!isClass && !isInterface) {
                     Debug.fail("type must be class or interface");
@@ -2868,11 +2870,11 @@ namespace ts {
 
         function resolveBaseTypesOfClass(type: InterfaceType): void {
             type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
-            let baseContructorType = getBaseConstructorTypeOfClass(type);
+            const baseContructorType = getBaseConstructorTypeOfClass(type);
             if (!(baseContructorType.flags & TypeFlags.ObjectType)) {
                 return;
             }
-            let baseTypeNode = getBaseTypeNodeOfClass(type);
+            const baseTypeNode = getBaseTypeNodeOfClass(type);
             let baseType: Type;
             if (baseContructorType.symbol && baseContructorType.symbol.flags & SymbolFlags.Class) {
                 // When base constructor type is a class we know that the constructors all have the same type parameters as the
@@ -2884,7 +2886,7 @@ namespace ts {
                 // The class derives from a "class-like" constructor function, check that we have at least one construct signature
                 // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere
                 // we check that all instantiated signatures return the same type.
-                let constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments);
+                const constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments);
                 if (!constructors.length) {
                     error(baseTypeNode.expression, Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
                     return;
@@ -2913,10 +2915,10 @@ namespace ts {
 
         function resolveBaseTypesOfInterface(type: InterfaceType): void {
             type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
-            for (let declaration of type.symbol.declarations) {
+            for (const declaration of type.symbol.declarations) {
                 if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
-                    for (let node of getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
-                        let baseType = getTypeFromTypeNode(node);
+                    for (const node of getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
+                        const baseType = getTypeFromTypeNode(node);
                         if (baseType !== unknownType) {
                             if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
                                 if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
@@ -2944,16 +2946,16 @@ namespace ts {
         // true if the interface itself contains no references to "this" in its body, if all base types are interfaces,
         // and if none of the base interfaces have a "this" type.
         function isIndependentInterface(symbol: Symbol): boolean {
-            for (let declaration of symbol.declarations) {
+            for (const declaration of symbol.declarations) {
                 if (declaration.kind === SyntaxKind.InterfaceDeclaration) {
                     if (declaration.flags & NodeFlags.ContainsThis) {
                         return false;
                     }
-                    let baseTypeNodes = getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration);
+                    const baseTypeNodes = getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration);
                     if (baseTypeNodes) {
-                        for (let node of baseTypeNodes) {
+                        for (const node of baseTypeNodes) {
                             if (isSupportedExpressionWithTypeArguments(node)) {
-                                let baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true);
+                                const baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true);
                                 if (!baseSymbol || !(baseSymbol.flags & SymbolFlags.Interface) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
                                     return false;
                                 }
@@ -2966,12 +2968,12 @@ namespace ts {
         }
 
         function getDeclaredTypeOfClassOrInterface(symbol: Symbol): InterfaceType {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.declaredType) {
-                let kind = symbol.flags & SymbolFlags.Class ? TypeFlags.Class : TypeFlags.Interface;
-                let type = links.declaredType = <InterfaceType>createObjectType(kind, symbol);
-                let outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
-                let localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
+                const kind = symbol.flags & SymbolFlags.Class ? TypeFlags.Class : TypeFlags.Interface;
+                const type = links.declaredType = <InterfaceType>createObjectType(kind, symbol);
+                const outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
+                const localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
                 // A class or interface is generic if it has type parameters or a "this" type. We always give classes a "this" type
                 // because it is not feasible to analyze all members to determine if the "this" type escapes the class (in particular,
                 // property types inferred from initializers and method return types inferred from return statements are very hard
@@ -2995,14 +2997,14 @@ namespace ts {
         }
 
         function getDeclaredTypeOfTypeAlias(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.declaredType) {
                 // Note that we use the links object as the target here because the symbol object is used as the unique
                 // identity for resolution of the 'type' property in SymbolLinks.
                 if (!pushTypeResolution(symbol, TypeSystemPropertyName.DeclaredType)) {
                     return unknownType;
                 }
-                let declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
+                const declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
                 let type = getTypeFromTypeNode(declaration.type);
                 if (popTypeResolution()) {
                     links.typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
@@ -3023,9 +3025,9 @@ namespace ts {
         }
 
         function getDeclaredTypeOfEnum(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.declaredType) {
-                let type = createType(TypeFlags.Enum);
+                const type = createType(TypeFlags.Enum);
                 type.symbol = symbol;
                 links.declaredType = type;
             }
@@ -3033,9 +3035,9 @@ namespace ts {
         }
 
         function getDeclaredTypeOfTypeParameter(symbol: Symbol): TypeParameter {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.declaredType) {
-                let type = <TypeParameter>createType(TypeFlags.TypeParameter);
+                const type = <TypeParameter>createType(TypeFlags.TypeParameter);
                 type.symbol = symbol;
                 if (!(<TypeParameterDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeParameter)).constraint) {
                     type.constraint = noConstraintType;
@@ -3046,7 +3048,7 @@ namespace ts {
         }
 
         function getDeclaredTypeOfAlias(symbol: Symbol): Type {
-            let links = getSymbolLinks(symbol);
+            const links = getSymbolLinks(symbol);
             if (!links.declaredType) {
                 links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol));
             }
@@ -3076,7 +3078,7 @@ namespace ts {
         // A type reference is considered independent if each type argument is considered independent.
         function isIndependentTypeReference(node: TypeReferenceNode): boolean {
             if (node.typeArguments) {
-                for (let typeNode of node.typeArguments) {
+                for (const typeNode of node.typeArguments) {
                     if (!isIndependentType(typeNode)) {
                         return false;
                     }
@@ -3118,7 +3120,7 @@ namespace ts {
             if (node.kind !== SyntaxKind.Constructor && (!node.type || !isIndependentType(node.type))) {
                 return false;
             }
-            for (let parameter of node.parameters) {
+            for (const parameter of node.parameters) {
                 if (!isIndependentVariableLikeDeclaration(parameter)) {
                     return false;
                 }
@@ -3133,7 +3135,7 @@ namespace ts {
         // assumed not to be free of "this" references.
         function isIndependentMember(symbol: Symbol): boolean {
             if (symbol.declarations && symbol.declarations.length === 1) {
-                let declaration = symbol.declarations[0];
+                const declaration = symbol.declarations[0];
                 if (declaration) {
                     switch (declaration.kind) {
                         case SyntaxKind.PropertyDeclaration:
@@ -3150,8 +3152,8 @@ namespace ts {
         }
 
         function createSymbolTable(symbols: Symbol[]): SymbolTable {
-            let result: SymbolTable = {};
-            for (let symbol of symbols) {
+            const result: SymbolTable = {};
+            for (const symbol of symbols) {
                 result[symbol.name] = symbol;
             }
             return result;
@@ -3160,15 +3162,15 @@ namespace ts {
         // The mappingThisOnly flag indicates that the only type parameter being mapped is "this". When the flag is true,
         // we check symbols to see if we can quickly conclude they are free of "this" references, thus needing no instantiation.
         function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper, mappingThisOnly: boolean): SymbolTable {
-            let result: SymbolTable = {};
-            for (let symbol of symbols) {
+            const result: SymbolTable = {};
+            for (const symbol of symbols) {
                 result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
             }
             return result;
         }
 
         function addInheritedMembers(symbols: SymbolTable, baseSymbols: Symbol[]) {
-            for (let s of baseSymbols) {
+            for (const s of baseSymbols) {
                 if (!hasProperty(symbols, s.name)) {
                     symbols[s.name] = s;
                 }
@@ -3177,7 +3179,7 @@ namespace ts {
 
         function addInheritedSignatures(signatures: Signature[], baseSignatures: Signature[]) {
             if (baseSignatures) {
-                for (let signature of baseSignatures) {
+                for (const signature of baseSignatures) {
                     signatures.push(signature);
                 }
             }
@@ -3185,7 +3187,7 @@ namespace ts {
 
         function resolveDeclaredMembers(type: InterfaceType): InterfaceTypeWithDeclaredMembers {
             if (!(<InterfaceTypeWithDeclaredMembers>type).declaredProperties) {
-                let symbol = type.symbol;
+                const symbol = type.symbol;
                 (<InterfaceTypeWithDeclaredMembers>type).declaredProperties = getNamedMembers(symbol.members);
                 (<InterfaceTypeWithDeclaredMembers>type).declaredCallSignatures = getSignaturesOfSymbol(symbol.members["__call"]);
                 (<InterfaceTypeWithDeclaredMembers>type).declaredConstructSignatures = getSignaturesOfSymbol(symbol.members["__new"]);
@@ -3218,14 +3220,14 @@ namespace ts {
                 stringIndexType = instantiateType(source.declaredStringIndexType, mapper);
                 numberIndexType = instantiateType(source.declaredNumberIndexType, mapper);
             }
-            let baseTypes = getBaseTypes(source);
+            const baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
                 if (members === source.symbol.members) {
                     members = createSymbolTable(source.declaredProperties);
                 }
-                let thisArgument = lastOrUndefined(typeArguments);
-                for (let baseType of baseTypes) {
-                    let instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
+                const thisArgument = lastOrUndefined(typeArguments);
+                for (const baseType of baseTypes) {
+                    const instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
                     addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType));
                     callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Call));
                     constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Construct));
@@ -3241,16 +3243,16 @@ namespace ts {
         }
 
         function resolveTypeReferenceMembers(type: TypeReference): void {
-            let source = resolveDeclaredMembers(type.target);
-            let typeParameters = concatenate(source.typeParameters, [source.thisType]);
-            let typeArguments = type.typeArguments && type.typeArguments.length === typeParameters.length ?
+            const source = resolveDeclaredMembers(type.target);
+            const typeParameters = concatenate(source.typeParameters, [source.thisType]);
+            const typeArguments = type.typeArguments && type.typeArguments.length === typeParameters.length ?
                 type.typeArguments : concatenate(type.typeArguments, [type]);
             resolveObjectTypeMembers(type, source, typeParameters, typeArguments);
         }
 
         function createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[], parameters: Symbol[],
             resolvedReturnType: Type, typePredicate: TypePredicate, minArgumentCount: number, hasRestParameter: boolean, hasStringLiterals: boolean): Signature {
-            let sig = new Signature(checker);
+            const sig = new Signature(checker);
             sig.declaration = declaration;
             sig.typeParameters = typeParameters;
             sig.parameters = parameters;
@@ -3271,16 +3273,16 @@ namespace ts {
             if (!hasClassBaseType(classType)) {
                 return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)];
             }
-            let baseConstructorType = getBaseConstructorTypeOfClass(classType);
-            let baseSignatures = getSignaturesOfType(baseConstructorType, SignatureKind.Construct);
-            let baseTypeNode = getBaseTypeNodeOfClass(classType);
-            let typeArguments = map(baseTypeNode.typeArguments, getTypeFromTypeNode);
-            let typeArgCount = typeArguments ? typeArguments.length : 0;
-            let result: Signature[] = [];
-            for (let baseSig of baseSignatures) {
-                let typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
+            const baseConstructorType = getBaseConstructorTypeOfClass(classType);
+            const baseSignatures = getSignaturesOfType(baseConstructorType, SignatureKind.Construct);
+            const baseTypeNode = getBaseTypeNodeOfClass(classType);
+            const typeArguments = map(baseTypeNode.typeArguments, getTypeFromTypeNode);
+            const typeArgCount = typeArguments ? typeArguments.length : 0;
+            const result: Signature[] = [];
+            for (const baseSig of baseSignatures) {
+                const typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
                 if (typeParamCount === typeArgCount) {
-                    let sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
+                    const sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
                     sig.typeParameters = classType.localTypeParameters;
                     sig.resolvedReturnType = classType;
                     result.push(sig);
@@ -3290,9 +3292,9 @@ namespace ts {
         }
 
         function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
-            let members: SymbolTable = {};
+            const members: SymbolTable = {};
             for (let i = 0; i < memberTypes.length; i++) {
-                let symbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
+                const symbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
                 symbol.type = memberTypes[i];
                 members[i] = symbol;
             }
@@ -3300,16 +3302,16 @@ namespace ts {
         }
 
         function resolveTupleTypeMembers(type: TupleType) {
-            let arrayElementType = getUnionType(type.elementTypes, /*noSubtypeReduction*/ true);
+            const arrayElementType = getUnionType(type.elementTypes, /*noSubtypeReduction*/ true);
             // Make the tuple type itself the 'this' type by including an extra type argument
-            let arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type]));
-            let members = createTupleTypeMemberSymbols(type.elementTypes);
+            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type]));
+            const members = createTupleTypeMemberSymbols(type.elementTypes);
             addInheritedMembers(members, arrayType.properties);
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
         }
 
         function findMatchingSignature(signatureList: Signature[], signature: Signature, partialMatch: boolean, ignoreReturnTypes: boolean): Signature {
-            for (let s of signatureList) {
+            for (const s of signatureList) {
                 if (compareSignatures(s, signature, partialMatch, ignoreReturnTypes, compareTypes)) {
                     return s;
                 }
@@ -3333,7 +3335,7 @@ namespace ts {
             let result: Signature[] = undefined;
             for (let i = 0; i < signatureLists.length; i++) {
                 // Allow matching non-generic signatures to have excess parameters and different return types
-                let match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, /*partialMatch*/ true, /*ignoreReturnTypes*/ true);
+                const match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, /*partialMatch*/ true, /*ignoreReturnTypes*/ true);
                 if (!match) {
                     return undefined;
                 }
@@ -3349,13 +3351,13 @@ namespace ts {
         // parameters and may differ in return types. When signatures differ in return types, the resulting return
         // type is the union of the constituent return types.
         function getUnionSignatures(types: Type[], kind: SignatureKind): Signature[] {
-            let signatureLists = map(types, t => getSignaturesOfType(t, kind));
+            const signatureLists = map(types, t => getSignaturesOfType(t, kind));
             let result: Signature[] = undefined;
             for (let i = 0; i < signatureLists.length; i++) {
-                for (let signature of signatureLists[i]) {
+                for (const signature of signatureLists[i]) {
                     // Only process signatures with parameter lists that aren't already in the result list
                     if (!result || !findMatchingSignature(result, signature, /*partialMatch*/ false, /*ignoreReturnTypes*/ true)) {
-                        let unionSignatures = findMatchingSignatures(signatureLists, signature, i);
+                        const unionSignatures = findMatchingSignatures(signatureLists, signature, i);
                         if (unionSignatures) {
                             let s = signature;
                             // Union the result types when more than one signature matches
@@ -3374,9 +3376,9 @@ namespace ts {
         }
 
         function getUnionIndexType(types: Type[], kind: IndexKind): Type {
-            let indexTypes: Type[] = [];
-            for (let type of types) {
-                let indexType = getIndexTypeOfType(type, kind);
+            const indexTypes: Type[] = [];
+            for (const type of types) {
+                const indexType = getIndexTypeOfType(type, kind);
                 if (!indexType) {
                     return undefined;
                 }
@@ -3388,10 +3390,10 @@ namespace ts {
         function resolveUnionTypeMembers(type: UnionType) {
             // The members and properties collections are empty for union types. To get all properties of a union
             // type use getPropertiesOfType (only the language service uses this).
-            let callSignatures = getUnionSignatures(type.types, SignatureKind.Call);
-            let constructSignatures = getUnionSignatures(type.types, SignatureKind.Construct);
-            let stringIndexType = getUnionIndexType(type.types, IndexKind.String);
-            let numberIndexType = getUnionIndexType(type.types, IndexKind.Number);
+            const callSignatures = getUnionSignatures(type.types, SignatureKind.Call);
+            const constructSignatures = getUnionSignatures(type.types, SignatureKind.Construct);
+            const stringIndexType = getUnionIndexType(type.types, IndexKind.String);
+            const numberIndexType = getUnionIndexType(type.types, IndexKind.Number);
             setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType);
         }
 
@@ -3406,7 +3408,7 @@ namespace ts {
             let constructSignatures: Signature[] = emptyArray;
             let stringIndexType: Type = undefined;
             let numberIndexType: Type = undefined;
-            for (let t of type.types) {
+            for (const t of type.types) {
                 callSignatures = concatenate(callSignatures, getSignaturesOfType(t, SignatureKind.Call));
                 constructSignatures = concatenate(constructSignatures, getSignaturesOfType(t, SignatureKind.Construct));
                 stringIndexType = intersectTypes(stringIndexType, getIndexTypeOfType(t, IndexKind.String));
@@ -3416,7 +3418,7 @@ namespace ts {
         }
 
         function resolveAnonymousTypeMembers(type: AnonymousType) {
-            let symbol = type.symbol;
+            const symbol = type.symbol;
             let members: SymbolTable;
             let callSignatures: Signature[];
             let constructSignatures: Signature[];
@@ -3449,12 +3451,12 @@ namespace ts {
                     callSignatures = getSignaturesOfSymbol(symbol);
                 }
                 if (symbol.flags & SymbolFlags.Class) {
-                    let classType = getDeclaredTypeOfClassOrInterface(symbol);
+                    const classType = getDeclaredTypeOfClassOrInterface(symbol);
                     constructSignatures = getSignaturesOfSymbol(symbol.members["__constructor"]);
                     if (!constructSignatures.length) {
                         constructSignatures = getDefaultConstructSignatures(classType);
                     }
-                    let baseConstructorType = getBaseConstructorTypeOfClass(classType);
+                    const baseConstructorType = getBaseConstructorTypeOfClass(classType);
                     if (baseConstructorType.flags & TypeFlags.ObjectType) {
                         members = createSymbolTable(getNamedMembers(members));
                         addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType));
@@ -3502,9 +3504,9 @@ namespace ts {
         // return the symbol for that property.Otherwise return undefined.
         function getPropertyOfObjectType(type: Type, name: string): Symbol {
             if (type.flags & TypeFlags.ObjectType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 if (hasProperty(resolved.members, name)) {
-                    let symbol = resolved.members[name];
+                    const symbol = resolved.members[name];
                     if (symbolIsValue(symbol)) {
                         return symbol;
                     }
@@ -3513,8 +3515,8 @@ namespace ts {
         }
 
         function getPropertiesOfUnionOrIntersectionType(type: UnionOrIntersectionType): Symbol[] {
-            for (let current of type.types) {
-                for (let prop of getPropertiesOfType(current)) {
+            for (const current of type.types) {
+                for (const prop of getPropertiesOfType(current)) {
                     getPropertyOfUnionOrIntersectionType(type, prop.name);
                 }
                 // The properties of a union type are those that are present in all constituent types, so
@@ -3561,12 +3563,12 @@ namespace ts {
         }
 
         function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: string): Symbol {
-            let types = containingType.types;
+            const types = containingType.types;
             let props: Symbol[];
-            for (let current of types) {
-                let type = getApparentType(current);
+            for (const current of types) {
+                const type = getApparentType(current);
                 if (type !== unknownType) {
-                    let prop = getPropertyOfType(type, name);
+                    const prop = getPropertyOfType(type, name);
                     if (prop && !(getDeclarationFlagsFromSymbol(prop) & (NodeFlags.Private | NodeFlags.Protected))) {
                         if (!props) {
                             props = [prop];
@@ -3587,15 +3589,15 @@ namespace ts {
             if (props.length === 1) {
                 return props[0];
             }
-            let propTypes: Type[] = [];
-            let declarations: Declaration[] = [];
-            for (let prop of props) {
+            const propTypes: Type[] = [];
+            const declarations: Declaration[] = [];
+            for (const prop of props) {
                 if (prop.declarations) {
                     addRange(declarations, prop.declarations);
                 }
                 propTypes.push(getTypeOfSymbol(prop));
             }
-            let result = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.SyntheticProperty, name);
+            const result = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | SymbolFlags.SyntheticProperty, name);
             result.containingType = containingType;
             result.declarations = declarations;
             result.type = containingType.flags & TypeFlags.Union ? getUnionType(propTypes) : getIntersectionType(propTypes);
@@ -3603,11 +3605,11 @@ namespace ts {
         }
 
         function getPropertyOfUnionOrIntersectionType(type: UnionOrIntersectionType, name: string): Symbol {
-            let properties = type.resolvedProperties || (type.resolvedProperties = {});
+            const properties = type.resolvedProperties || (type.resolvedProperties = {});
             if (hasProperty(properties, name)) {
                 return properties[name];
             }
-            let property = createUnionOrIntersectionProperty(type, name);
+            const property = createUnionOrIntersectionProperty(type, name);
             if (property) {
                 properties[name] = property;
             }
@@ -3620,15 +3622,15 @@ namespace ts {
         function getPropertyOfType(type: Type, name: string): Symbol {
             type = getApparentType(type);
             if (type.flags & TypeFlags.ObjectType) {
-                let resolved = resolveStructuredTypeMembers(type);
+                const resolved = resolveStructuredTypeMembers(type);
                 if (hasProperty(resolved.members, name)) {
-                    let symbol = resolved.members[name];
+                    const symbol = resolved.members[name];
                     if (symbolIsValue(symbol)) {
                         return symbol;
                     }
                 }
                 if (resolved === anyFunctionType || resolved.callSignatures.length || resolved.constructSignatures.length) {
-                    let symbol = getPropertyOfObjectType(globalFunctionType, name);
+                    const symbol = getPropertyOfObjectType(globalFunctionType, name);
                     if (symbol) {
                         return symbol;
                     }
@@ -3643,7 +3645,7 @@ namespace ts {
 
         function getSignaturesOfStructuredType(type: Type, kind: SignatureKind): Signature[] {
             if (type.flags & TypeFlags.StructuredType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 return kind === SignatureKind.Call ? resolved.callSignatures : resolved.constructSignatures;
             }
             return emptyArray;
@@ -3658,18 +3660,18 @@ namespace ts {
         }
 
         function typeHasConstructSignatures(type: Type): boolean {
-            let apparentType = getApparentType(type);
+            const apparentType = getApparentType(type);
             if (apparentType.flags & (TypeFlags.ObjectType | TypeFlags.Union)) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 return resolved.constructSignatures.length > 0;
             }
             return false;
         }
 
         function typeHasCallOrConstructSignatures(type: Type): boolean {
-            let apparentType = getApparentType(type);
+            const apparentType = getApparentType(type);
             if (apparentType.flags & TypeFlags.StructuredType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 return resolved.callSignatures.length > 0 || resolved.constructSignatures.length > 0;
             }
             return false;
@@ -3677,7 +3679,7 @@ namespace ts {
 
         function getIndexTypeOfStructuredType(type: Type, kind: IndexKind): Type {
             if (type.flags & TypeFlags.StructuredType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 return kind === IndexKind.String ? resolved.stringIndexType : resolved.numberIndexType;
             }
         }
@@ -3691,9 +3693,9 @@ namespace ts {
         // Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual
         // type checking functions).
         function getTypeParametersFromDeclaration(typeParameterDeclarations: TypeParameterDeclaration[]): TypeParameter[] {
-            let result: TypeParameter[] = [];
+            const result: TypeParameter[] = [];
             forEach(typeParameterDeclarations, node => {
-                let tp = getDeclaredTypeOfTypeParameter(node.symbol);
+                const tp = getDeclaredTypeOfTypeParameter(node.symbol);
                 if (!contains(result, tp)) {
                     result.push(tp);
                 }
@@ -3702,8 +3704,8 @@ namespace ts {
         }
 
         function symbolsToArray(symbols: SymbolTable): Symbol[] {
-            let result: Symbol[] = [];
-            for (let id in symbols) {
+            const result: Symbol[] = [];
+            for (const id in symbols) {
                 if (!isReservedMemberName(id)) {
                     result.push(symbols[id]);
                 }
@@ -3717,9 +3719,9 @@ namespace ts {
             }
 
             if (node.initializer) {
-                let signatureDeclaration = <SignatureDeclaration>node.parent;
-                let signature = getSignatureFromDeclaration(signatureDeclaration);
-                let parameterIndex = signatureDeclaration.parameters.indexOf(node);
+                const signatureDeclaration = <SignatureDeclaration>node.parent;
+                const signature = getSignatureFromDeclaration(signatureDeclaration);
+                const parameterIndex = signatureDeclaration.parameters.indexOf(node);
                 Debug.assert(parameterIndex >= 0);
                 return parameterIndex >= signature.minArgumentCount;
             }
@@ -3728,18 +3730,18 @@ namespace ts {
         }
 
         function getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature {
-            let links = getNodeLinks(declaration);
+            const links = getNodeLinks(declaration);
             if (!links.resolvedSignature) {
-                let classType = declaration.kind === SyntaxKind.Constructor ?
+                const classType = declaration.kind === SyntaxKind.Constructor ?
                     getDeclaredTypeOfClassOrInterface(getMergedSymbol((<ClassDeclaration>declaration.parent).symbol))
                     : undefined;
-                let typeParameters = classType ? classType.localTypeParameters :
+                const typeParameters = classType ? classType.localTypeParameters :
                     declaration.typeParameters ? getTypeParametersFromDeclaration(declaration.typeParameters) : undefined;
-                let parameters: Symbol[] = [];
+                const parameters: Symbol[] = [];
                 let hasStringLiterals = false;
                 let minArgumentCount = -1;
                 for (let i = 0, n = declaration.parameters.length; i < n; i++) {
-                    let param = declaration.parameters[i];
+                    const param = declaration.parameters[i];
                     parameters.push(param.symbol);
                     if (param.type && param.type.kind === SyntaxKind.StringLiteral) {
                         hasStringLiterals = true;
@@ -3768,7 +3770,7 @@ namespace ts {
                 else if (declaration.type) {
                     returnType = getTypeFromTypeNode(declaration.type);
                     if (declaration.type.kind === SyntaxKind.TypePredicate) {
-                        let typePredicateNode = <TypePredicateNode>declaration.type;
+                        const typePredicateNode = <TypePredicateNode>declaration.type;
                         typePredicate = {
                             parameterName: typePredicateNode.parameterName ? typePredicateNode.parameterName.text : undefined,
                             parameterIndex: typePredicateNode.parameterName ? getTypePredicateParameterIndex(declaration.parameters, typePredicateNode.parameterName) : undefined,
@@ -3780,7 +3782,7 @@ namespace ts {
                     // TypeScript 1.0 spec (April 2014):
                     // If only one accessor includes a type annotation, the other behaves as if it had the same type annotation.
                     if (declaration.kind === SyntaxKind.GetAccessor && !hasDynamicName(declaration)) {
-                        let setter = <AccessorDeclaration>getDeclarationOfKind(declaration.symbol, SyntaxKind.SetAccessor);
+                        const setter = <AccessorDeclaration>getDeclarationOfKind(declaration.symbol, SyntaxKind.SetAccessor);
                         returnType = getAnnotatedAccessorType(setter);
                     }
 
@@ -3797,9 +3799,9 @@ namespace ts {
 
         function getSignaturesOfSymbol(symbol: Symbol): Signature[] {
             if (!symbol) return emptyArray;
-            let result: Signature[] = [];
+            const result: Signature[] = [];
             for (let i = 0, len = symbol.declarations.length; i < len; i++) {
-                let node = symbol.declarations[i];
+                const node = symbol.declarations[i];
                 switch (node.kind) {
                     case SyntaxKind.FunctionType:
                     case SyntaxKind.ConstructorType:
@@ -3818,7 +3820,7 @@ namespace ts {
                         // an implementation node if it has a body and the previous node is of the same kind and immediately
                         // precedes the implementation node (i.e. has the same parent and ends where the implementation starts).
                         if (i > 0 && (<FunctionLikeDeclaration>node).body) {
-                            let previous = symbol.declarations[i - 1];
+                            const previous = symbol.declarations[i - 1];
                             if (node.parent === previous.parent && node.kind === previous.kind && node.pos === previous.end) {
                                 break;
                             }
@@ -3847,7 +3849,7 @@ namespace ts {
                 if (!popTypeResolution()) {
                     type = anyType;
                     if (compilerOptions.noImplicitAny) {
-                        let declaration = <Declaration>signature.declaration;
+                        const declaration = <Declaration>signature.declaration;
                         if (declaration.name) {
                             error(declaration.name, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, declarationNameToString(declaration.name));
                         }
@@ -3863,7 +3865,7 @@ namespace ts {
 
         function getRestTypeOfSignature(signature: Signature): Type {
             if (signature.hasRestParameter) {
-                let type = getTypeOfSymbol(lastOrUndefined(signature.parameters));
+                const type = getTypeOfSymbol(lastOrUndefined(signature.parameters));
                 if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType) {
                     return (<TypeReference>type).typeArguments[0];
                 }
@@ -3894,8 +3896,8 @@ namespace ts {
             // object type literal or interface (using the new keyword). Each way of declaring a constructor
             // will result in a different declaration kind.
             if (!signature.isolatedSignatureType) {
-                let isConstructor = signature.declaration.kind === SyntaxKind.Constructor || signature.declaration.kind === SyntaxKind.ConstructSignature;
-                let type = <ResolvedType>createObjectType(TypeFlags.Anonymous | TypeFlags.FromSignature);
+                const isConstructor = signature.declaration.kind === SyntaxKind.Constructor || signature.declaration.kind === SyntaxKind.ConstructSignature;
+                const type = <ResolvedType>createObjectType(TypeFlags.Anonymous | TypeFlags.FromSignature);
                 type.members = emptySymbols;
                 type.properties = emptyArray;
                 type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -3911,13 +3913,13 @@ namespace ts {
         }
 
         function getIndexDeclarationOfSymbol(symbol: Symbol, kind: IndexKind): SignatureDeclaration {
-            let syntaxKind = kind === IndexKind.Number ? SyntaxKind.NumberKeyword : SyntaxKind.StringKeyword;
-            let indexSymbol = getIndexSymbol(symbol);
+            const syntaxKind = kind === IndexKind.Number ? SyntaxKind.NumberKeyword : SyntaxKind.StringKeyword;
+            const indexSymbol = getIndexSymbol(symbol);
             if (indexSymbol) {
-                for (let decl of indexSymbol.declarations) {
-                    let node = <SignatureDeclaration>decl;
+                for (const decl of indexSymbol.declarations) {
+                    const node = <SignatureDeclaration>decl;
                     if (node.parameters.length === 1) {
-                        let parameter = node.parameters[0];
+                        const parameter = node.parameters[0];
                         if (parameter && parameter.type && parameter.type.kind === syntaxKind) {
                             return node;
                         }
@@ -3929,7 +3931,7 @@ namespace ts {
         }
 
         function getIndexTypeOfSymbol(symbol: Symbol, kind: IndexKind): Type {
-            let declaration = getIndexDeclarationOfSymbol(symbol, kind);
+            const declaration = getIndexDeclarationOfSymbol(symbol, kind);
             return declaration
                 ? declaration.type ? getTypeFromTypeNode(declaration.type) : anyType
                 : undefined;
@@ -3938,7 +3940,7 @@ namespace ts {
         function getConstraintOfTypeParameter(type: TypeParameter): Type {
             if (!type.constraint) {
                 if (type.target) {
-                    let targetConstraint = getConstraintOfTypeParameter(type.target);
+                    const targetConstraint = getConstraintOfTypeParameter(type.target);
                     type.constraint = targetConstraint ? instantiateType(targetConstraint, type.mapper) : noConstraintType;
                 }
                 else {
@@ -3979,17 +3981,17 @@ namespace ts {
         // that care about the presence of such types at arbitrary depth in a containing type.
         function getPropagatingFlagsOfTypes(types: Type[]): TypeFlags {
             let result: TypeFlags = 0;
-            for (let type of types) {
+            for (const type of types) {
                 result |= type.flags;
             }
             return result & TypeFlags.PropagatingFlags;
         }
 
         function createTypeReference(target: GenericType, typeArguments: Type[]): TypeReference {
-            let id = getTypeListId(typeArguments);
+            const id = getTypeListId(typeArguments);
             let type = target.instantiations[id];
             if (!type) {
-                let flags = TypeFlags.Reference | (typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0);
+                const flags = TypeFlags.Reference | (typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0);
                 type = target.instantiations[id] = <TypeReference>createObjectType(flags, target.symbol);
                 type.target = target;
                 type.typeArguments = typeArguments;
@@ -3998,7 +4000,7 @@ namespace ts {
         }
 
         function isTypeParameterReferenceIllegalInConstraint(typeReferenceNode: TypeReferenceNode | ExpressionWithTypeArguments, typeParameterSymbol: Symbol): boolean {
-            let links = getNodeLinks(typeReferenceNode);
+            const links = getNodeLinks(typeReferenceNode);
             if (links.isIllegalTypeReferenceInConstraint !== undefined) {
                 return links.isIllegalTypeReferenceInConstraint;
             }
@@ -4018,9 +4020,9 @@ namespace ts {
             let typeParameterSymbol: Symbol;
             function check(n: Node): void {
                 if (n.kind === SyntaxKind.TypeReference && (<TypeReferenceNode>n).typeName.kind === SyntaxKind.Identifier) {
-                    let links = getNodeLinks(n);
+                    const links = getNodeLinks(n);
                     if (links.isIllegalTypeReferenceInConstraint === undefined) {
-                        let symbol = resolveName(typeParameter, (<Identifier>(<TypeReferenceNode>n).typeName).text, SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+                        const symbol = resolveName(typeParameter, (<Identifier>(<TypeReferenceNode>n).typeName).text, SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
                         if (symbol && (symbol.flags & SymbolFlags.TypeParameter)) {
                             // TypeScript 1.0 spec (April 2014): 3.4.1
                             // Type parameters declared in a particular type parameter list
@@ -4048,8 +4050,8 @@ namespace ts {
 
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node: TypeReferenceNode | ExpressionWithTypeArguments, symbol: Symbol): Type {
-            let type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
-            let typeParameters = type.localTypeParameters;
+            const type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
+            const typeParameters = type.localTypeParameters;
             if (typeParameters) {
                 if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) {
                     error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length);
@@ -4071,16 +4073,16 @@ namespace ts {
         // references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the
         // declared type. Instantiations are cached using the type identities of the type arguments as the key.
         function getTypeFromTypeAliasReference(node: TypeReferenceNode | ExpressionWithTypeArguments, symbol: Symbol): Type {
-            let type = getDeclaredTypeOfSymbol(symbol);
-            let links = getSymbolLinks(symbol);
-            let typeParameters = links.typeParameters;
+            const type = getDeclaredTypeOfSymbol(symbol);
+            const links = getSymbolLinks(symbol);
+            const typeParameters = links.typeParameters;
             if (typeParameters) {
                 if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) {
                     error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, symbolToString(symbol), typeParameters.length);
                     return unknownType;
                 }
-                let typeArguments = map(node.typeArguments, getTypeFromTypeNode);
-                let id = getTypeListId(typeArguments);
+                const typeArguments = map(node.typeArguments, getTypeFromTypeNode);
+                const id = getTypeListId(typeArguments);
                 return links.instantiations[id] || (links.instantiations[id] = instantiateType(type, createTypeMapper(typeParameters, typeArguments)));
             }
             if (node.typeArguments) {
@@ -4107,14 +4109,14 @@ namespace ts {
         }
 
         function getTypeFromTypeReference(node: TypeReferenceNode | ExpressionWithTypeArguments): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 // We only support expressions that are simple qualified names. For other expressions this produces undefined.
-                let typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
+                const typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
                     isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node) ? (<ExpressionWithTypeArguments>node).expression :
                     undefined;
-                let symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
-                let type = symbol === unknownSymbol ? unknownType :
+                const symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
+                const type = symbol === unknownSymbol ? unknownType :
                     symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) :
                     symbol.flags & SymbolFlags.TypeAlias ? getTypeFromTypeAliasReference(node, symbol) :
                     getTypeFromNonGenericTypeReference(node, symbol);
@@ -4127,7 +4129,7 @@ namespace ts {
         }
 
         function getTypeFromTypeQueryNode(node: TypeQueryNode): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 // TypeScript 1.0 spec (April 2014): 3.6.3
                 // The expression is processed as an identifier expression (section 4.3)
@@ -4141,8 +4143,8 @@ namespace ts {
         function getTypeOfGlobalSymbol(symbol: Symbol, arity: number): ObjectType {
 
             function getTypeDeclaration(symbol: Symbol): Declaration {
-                let declarations = symbol.declarations;
-                for (let declaration of declarations) {
+                const declarations = symbol.declarations;
+                for (const declaration of declarations) {
                     switch (declaration.kind) {
                         case SyntaxKind.ClassDeclaration:
                         case SyntaxKind.InterfaceDeclaration:
@@ -4155,7 +4157,7 @@ namespace ts {
             if (!symbol) {
                 return arity ? emptyGenericType : emptyObjectType;
             }
-            let type = getDeclaredTypeOfSymbol(symbol);
+            const type = getDeclaredTypeOfSymbol(symbol);
             if (!(type.flags & TypeFlags.ObjectType)) {
                 error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbol.name);
                 return arity ? emptyGenericType : emptyObjectType;
@@ -4192,8 +4194,8 @@ namespace ts {
          * getExportedTypeFromNamespace('JSX', 'Element') returns the JSX.Element type
          */
         function getExportedTypeFromNamespace(namespace: string, name: string): Type {
-            let namespaceSymbol = getGlobalSymbol(namespace, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined);
-            let typeSymbol = namespaceSymbol && getSymbol(namespaceSymbol.exports, name, SymbolFlags.Type);
+            const namespaceSymbol = getGlobalSymbol(namespace, SymbolFlags.Namespace, /*diagnosticMessage*/ undefined);
+            const typeSymbol = namespaceSymbol && getSymbol(namespaceSymbol.exports, name, SymbolFlags.Type);
             return typeSymbol && getDeclaredTypeOfSymbol(typeSymbol);
         }
 
@@ -4205,7 +4207,7 @@ namespace ts {
           * Creates a TypeReference for a generic `TypedPropertyDescriptor<T>`.
           */
         function createTypedPropertyDescriptorType(propertyType: Type): Type {
-            let globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType();
+            const globalTypedPropertyDescriptorType = getGlobalTypedPropertyDescriptorType();
             return globalTypedPropertyDescriptorType !== emptyGenericType
                 ? createTypeReference(<GenericType>globalTypedPropertyDescriptorType, [propertyType])
                 : emptyObjectType;
@@ -4231,7 +4233,7 @@ namespace ts {
         }
 
         function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
             }
@@ -4239,18 +4241,18 @@ namespace ts {
         }
 
         function createTupleType(elementTypes: Type[]) {
-            let id = getTypeListId(elementTypes);
+            const id = getTypeListId(elementTypes);
             return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes));
         }
 
         function createNewTupleType(elementTypes: Type[]) {
-            let type = <TupleType>createObjectType(TypeFlags.Tuple | getPropagatingFlagsOfTypes(elementTypes));
+            const type = <TupleType>createObjectType(TypeFlags.Tuple | getPropagatingFlagsOfTypes(elementTypes));
             type.elementTypes = elementTypes;
             return type;
         }
 
         function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = createTupleType(map(node.elementTypes, getTypeFromTypeNode));
             }
@@ -4269,7 +4271,7 @@ namespace ts {
         // Add the given types to the given type set. Order is preserved, duplicates are removed,
         // and nested types of the given kind are flattened into the set.
         function addTypesToSet(typeSet: Type[], types: Type[], typeSetKind: TypeFlags) {
-            for (let type of types) {
+            for (const type of types) {
                 addTypeToSet(typeSet, type, typeSetKind);
             }
         }
@@ -4294,7 +4296,7 @@ namespace ts {
         }
 
         function containsTypeAny(types: Type[]): boolean {
-            for (let type of types) {
+            for (const type of types) {
                 if (isTypeAny(type)) {
                     return true;
                 }
@@ -4323,7 +4325,7 @@ namespace ts {
             if (types.length === 0) {
                 return emptyObjectType;
             }
-            let typeSet: Type[] = [];
+            const typeSet: Type[] = [];
             addTypesToSet(typeSet, types, TypeFlags.Union);
             if (containsTypeAny(typeSet)) {
                 return anyType;
@@ -4338,7 +4340,7 @@ namespace ts {
             if (typeSet.length === 1) {
                 return typeSet[0];
             }
-            let id = getTypeListId(typeSet);
+            const id = getTypeListId(typeSet);
             let type = unionTypes[id];
             if (!type) {
                 type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | getPropagatingFlagsOfTypes(typeSet));
@@ -4348,7 +4350,7 @@ namespace ts {
         }
 
         function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
             }
@@ -4364,7 +4366,7 @@ namespace ts {
             if (types.length === 0) {
                 return emptyObjectType;
             }
-            let typeSet: Type[] = [];
+            const typeSet: Type[] = [];
             addTypesToSet(typeSet, types, TypeFlags.Intersection);
             if (containsTypeAny(typeSet)) {
                 return anyType;
@@ -4372,7 +4374,7 @@ namespace ts {
             if (typeSet.length === 1) {
                 return typeSet[0];
             }
-            let id = getTypeListId(typeSet);
+            const id = getTypeListId(typeSet);
             let type = intersectionTypes[id];
             if (!type) {
                 type = intersectionTypes[id] = <IntersectionType>createObjectType(TypeFlags.Intersection | getPropagatingFlagsOfTypes(typeSet));
@@ -4382,7 +4384,7 @@ namespace ts {
         }
 
         function getTypeFromIntersectionTypeNode(node: IntersectionTypeNode): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = getIntersectionType(map(node.types, getTypeFromTypeNode));
             }
@@ -4390,7 +4392,7 @@ namespace ts {
         }
 
         function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node: Node): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 // Deferred resolution of members is handled by resolveObjectTypeMembers
                 links.resolvedType = createObjectType(TypeFlags.Anonymous, node.symbol);
@@ -4403,13 +4405,13 @@ namespace ts {
                 return stringLiteralTypes[node.text];
             }
 
-            let type = stringLiteralTypes[node.text] = <StringLiteralType>createType(TypeFlags.StringLiteral);
+            const type = stringLiteralTypes[node.text] = <StringLiteralType>createType(TypeFlags.StringLiteral);
             type.text = getTextOfNode(node);
             return type;
         }
 
         function getTypeFromStringLiteral(node: StringLiteral): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = getStringLiteralType(node);
             }
@@ -4417,10 +4419,11 @@ namespace ts {
         }
 
         function getThisType(node: TypeNode): Type {
-            let container = getThisContainer(node, /*includeArrowFunctions*/ false);
-            let parent = container && container.parent;
+            const container = getThisContainer(node, /*includeArrowFunctions*/ false);
+            const parent = container && container.parent;
             if (parent && (isClassLike(parent) || parent.kind === SyntaxKind.InterfaceDeclaration)) {
-                if (!(container.flags & NodeFlags.Static)) {
+                if (!(container.flags & NodeFlags.Static) &&
+                    (container.kind !== SyntaxKind.Constructor || isNodeDescendentOf(node, (<ConstructorDeclaration>container).body))) {
                     return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType;
                 }
             }
@@ -4429,7 +4432,7 @@ namespace ts {
         }
 
         function getTypeFromThisTypeNode(node: TypeNode): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = getThisType(node);
             }
@@ -4480,7 +4483,7 @@ namespace ts {
                 // Callers should first ensure this by calling isTypeNode
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
-                    let symbol = getSymbolAtLocation(node);
+                    const symbol = getSymbolAtLocation(node);
                     return symbol && getDeclaredTypeOfSymbol(symbol);
                 default:
                     return unknownType;
@@ -4489,8 +4492,8 @@ namespace ts {
 
         function instantiateList<T>(items: T[], mapper: TypeMapper, instantiator: (item: T, mapper: TypeMapper) => T): T[] {
             if (items && items.length) {
-                let result: T[] = [];
-                for (let v of items) {
+                const result: T[] = [];
+                for (const v of items) {
                     result.push(instantiator(v, mapper));
                 }
                 return result;
@@ -4535,7 +4538,7 @@ namespace ts {
                 case 2: return createBinaryTypeEraser(sources[0], sources[1]);
             }
             return t => {
-                for (let source of sources) {
+                for (const source of sources) {
                     if (t === source) {
                         return anyType;
                     }
@@ -4545,7 +4548,7 @@ namespace ts {
         }
 
         function createInferenceMapper(context: InferenceContext): TypeMapper {
-            let mapper: TypeMapper = t => {
+            const mapper: TypeMapper = t => {
                 for (let i = 0; i < context.typeParameters.length; i++) {
                     if (t === context.typeParameters[i]) {
                         context.inferences[i].isFixed = true;
@@ -4568,7 +4571,7 @@ namespace ts {
         }
 
         function instantiateTypeParameter(typeParameter: TypeParameter, mapper: TypeMapper): TypeParameter {
-            let result = <TypeParameter>createType(TypeFlags.TypeParameter);
+            const result = <TypeParameter>createType(TypeFlags.TypeParameter);
             result.symbol = typeParameter.symbol;
             if (typeParameter.constraint) {
                 result.constraint = instantiateType(typeParameter.constraint, mapper);
@@ -4594,7 +4597,7 @@ namespace ts {
                     type: instantiateType(signature.typePredicate.type, mapper)
                 };
             }
-            let result = createSignature(signature.declaration, freshTypeParameters,
+            const result = createSignature(signature.declaration, freshTypeParameters,
                 instantiateList(signature.parameters, mapper, instantiateSymbol),
                 instantiateType(signature.resolvedReturnType, mapper),
                 freshTypePredicate,
@@ -4606,7 +4609,7 @@ namespace ts {
 
         function instantiateSymbol(symbol: Symbol, mapper: TypeMapper): Symbol {
             if (symbol.flags & SymbolFlags.Instantiated) {
-                let links = getSymbolLinks(symbol);
+                const links = getSymbolLinks(symbol);
                 // If symbol being instantiated is itself a instantiation, fetch the original target and combine the
                 // type mappers. This ensures that original type identities are properly preserved and that aliases
                 // always reference a non-aliases.
@@ -4616,7 +4619,7 @@ namespace ts {
 
             // Keep the flags from the symbol we're instantiating.  Mark that is instantiated, and
             // also transient so that we can just store data on it directly.
-            let result = <TransientSymbol>createSymbol(SymbolFlags.Instantiated | SymbolFlags.Transient | symbol.flags, symbol.name);
+            const result = <TransientSymbol>createSymbol(SymbolFlags.Instantiated | SymbolFlags.Transient | symbol.flags, symbol.name);
             result.declarations = symbol.declarations;
             result.parent = symbol.parent;
             result.target = symbol;
@@ -4630,7 +4633,7 @@ namespace ts {
 
         function instantiateAnonymousType(type: AnonymousType, mapper: TypeMapper): ObjectType {
             if (mapper.instantiations) {
-                let cachedType = mapper.instantiations[type.id];
+                const cachedType = mapper.instantiations[type.id];
                 if (cachedType) {
                     return cachedType;
                 }
@@ -4639,7 +4642,7 @@ namespace ts {
                 mapper.instantiations = [];
             }
             // Mark the anonymous type as instantiated such that our infinite instantiation detection logic can recognize it
-            let result = <AnonymousType>createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol);
+            const result = <AnonymousType>createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol);
             result.target = type;
             result.mapper = mapper;
             mapper.instantiations[type.id] = result;
@@ -4707,9 +4710,9 @@ namespace ts {
 
         function getTypeWithoutSignatures(type: Type): Type {
             if (type.flags & TypeFlags.ObjectType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 if (resolved.constructSignatures.length) {
-                    let result = <ResolvedType>createObjectType(TypeFlags.Anonymous, type.symbol);
+                    const result = <ResolvedType>createObjectType(TypeFlags.Anonymous, type.symbol);
                     result.members = resolved.members;
                     result.properties = resolved.properties;
                     result.callSignatures = emptyArray;
@@ -4747,8 +4750,8 @@ namespace ts {
         }
 
         function isSignatureAssignableTo(source: Signature, target: Signature): boolean {
-            let sourceType = getOrCreateTypeFromSignature(source);
-            let targetType = getOrCreateTypeFromSignature(target);
+            const sourceType = getOrCreateTypeFromSignature(source);
+            const targetType = getOrCreateTypeFromSignature(target);
             return checkTypeRelatedTo(sourceType, targetType, assignableRelation, /*errorNode*/ undefined);
         }
 
@@ -4781,7 +4784,7 @@ namespace ts {
 
             Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
 
-            let result = isRelatedTo(source, target, errorNode !== undefined, headMessage);
+            const result = isRelatedTo(source, target, errorNode !== undefined, headMessage);
             if (overflow) {
                 error(errorNode, Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
             }
@@ -4855,7 +4858,7 @@ namespace ts {
                     }
                 }
 
-                let saveErrorInfo = errorInfo;
+                const saveErrorInfo = errorInfo;
 
                 // Note that the "each" checks must precede the "some" checks to produce the correct results
                 if (source.flags & TypeFlags.Union) {
@@ -4891,7 +4894,7 @@ namespace ts {
                         constraint = emptyObjectType;
                     }
                     // Report constraint errors only if the constraint is not the empty object type
-                    let reportConstraintErrors = reportErrors && constraint !== emptyObjectType;
+                    const reportConstraintErrors = reportErrors && constraint !== emptyObjectType;
                     if (result = isRelatedTo(constraint, target, reportConstraintErrors)) {
                         errorInfo = saveErrorInfo;
                         return result;
@@ -4906,13 +4909,13 @@ namespace ts {
                     }
                     // Even if relationship doesn't hold for unions, intersections, or generic type references,
                     // it may hold in a structural comparison.
-                    let apparentType = getApparentType(source);
+                    const apparentType = getApparentType(source);
                     // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates
                     // to X. Failing both of those we want to check if the aggregation of A and B's members structurally
                     // relates to X. Thus, we include intersection types on the source side here.
                     if (apparentType.flags & (TypeFlags.ObjectType | TypeFlags.Intersection) && target.flags & TypeFlags.ObjectType) {
                         // Report structural errors only if we haven't reported any errors yet
-                        let reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo;
+                        const reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo;
                         if (result = objectTypeRelatedTo(apparentType, source, target, reportStructuralErrors)) {
                             errorInfo = saveErrorInfo;
                             return result;
@@ -4964,7 +4967,7 @@ namespace ts {
                     }
                 }
                 else if (type.flags & TypeFlags.UnionOrIntersection) {
-                    for (let t of (<UnionOrIntersectionType>type).types) {
+                    for (const t of (<UnionOrIntersectionType>type).types) {
                         if (isKnownProperty(t, name)) {
                             return true;
                         }
@@ -4975,7 +4978,7 @@ namespace ts {
 
             function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {
                 if (someConstituentTypeHasKind(target, TypeFlags.ObjectType)) {
-                    for (let prop of getPropertiesOfObjectType(source)) {
+                    for (const prop of getPropertiesOfObjectType(source)) {
                         if (!isKnownProperty(target, prop.name)) {
                             if (reportErrors) {
                                 // We know *exactly* where things went wrong when comparing the types.
@@ -4994,9 +4997,9 @@ namespace ts {
 
             function eachTypeRelatedToSomeType(source: UnionOrIntersectionType, target: UnionOrIntersectionType): Ternary {
                 let result = Ternary.True;
-                let sourceTypes = source.types;
-                for (let sourceType of sourceTypes) {
-                    let related = typeRelatedToSomeType(sourceType, target, false);
+                const sourceTypes = source.types;
+                for (const sourceType of sourceTypes) {
+                    const related = typeRelatedToSomeType(sourceType, target, false);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5006,9 +5009,9 @@ namespace ts {
             }
 
             function typeRelatedToSomeType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary {
-                let targetTypes = target.types;
+                const targetTypes = target.types;
                 for (let i = 0, len = targetTypes.length; i < len; i++) {
-                    let related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1);
+                    const related = isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1);
                     if (related) {
                         return related;
                     }
@@ -5018,9 +5021,9 @@ namespace ts {
 
             function typeRelatedToEachType(source: Type, target: UnionOrIntersectionType, reportErrors: boolean): Ternary {
                 let result = Ternary.True;
-                let targetTypes = target.types;
-                for (let targetType of targetTypes) {
-                    let related = isRelatedTo(source, targetType, reportErrors);
+                const targetTypes = target.types;
+                for (const targetType of targetTypes) {
+                    const related = isRelatedTo(source, targetType, reportErrors);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5030,9 +5033,9 @@ namespace ts {
             }
 
             function someTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean): Ternary {
-                let sourceTypes = source.types;
+                const sourceTypes = source.types;
                 for (let i = 0, len = sourceTypes.length; i < len; i++) {
-                    let related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1);
+                    const related = isRelatedTo(sourceTypes[i], target, reportErrors && i === len - 1);
                     if (related) {
                         return related;
                     }
@@ -5042,9 +5045,9 @@ namespace ts {
 
             function eachTypeRelatedToType(source: UnionOrIntersectionType, target: Type, reportErrors: boolean): Ternary {
                 let result = Ternary.True;
-                let sourceTypes = source.types;
-                for (let sourceType of sourceTypes) {
-                    let related = isRelatedTo(sourceType, target, reportErrors);
+                const sourceTypes = source.types;
+                for (const sourceType of sourceTypes) {
+                    const related = isRelatedTo(sourceType, target, reportErrors);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5054,14 +5057,14 @@ namespace ts {
             }
 
             function typeArgumentsRelatedTo(source: TypeReference, target: TypeReference, reportErrors: boolean): Ternary {
-                let sources = source.typeArguments || emptyArray;
-                let targets = target.typeArguments || emptyArray;
+                const sources = source.typeArguments || emptyArray;
+                const targets = target.typeArguments || emptyArray;
                 if (sources.length !== targets.length && relation === identityRelation) {
                     return Ternary.False;
                 }
                 let result = Ternary.True;
                 for (let i = 0; i < targets.length; i++) {
-                    let related = isRelatedTo(sources[i], targets[i], reportErrors);
+                    const related = isRelatedTo(sources[i], targets[i], reportErrors);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5093,8 +5096,8 @@ namespace ts {
                 if (overflow) {
                     return Ternary.False;
                 }
-                let id = relation !== identityRelation || apparentSource.id < target.id ? apparentSource.id + "," + target.id : target.id + "," + apparentSource.id;
-                let related = relation[id];
+                const id = relation !== identityRelation || apparentSource.id < target.id ? apparentSource.id + "," + target.id : target.id + "," + apparentSource.id;
+                const related = relation[id];
                 if (related !== undefined) {
                     // If we computed this relation already and it was failed and reported, or if we're not being asked to elaborate
                     // errors, we can use the cached value. Otherwise, recompute the relation
@@ -5125,7 +5128,7 @@ namespace ts {
                 maybeStack[depth] = {};
                 maybeStack[depth][id] = RelationComparisonResult.Succeeded;
                 depth++;
-                let saveExpandingFlags = expandingFlags;
+                const saveExpandingFlags = expandingFlags;
                 if (!(expandingFlags & 1) && isDeeplyNestedGeneric(apparentSource, sourceStack, depth)) expandingFlags |= 1;
                 if (!(expandingFlags & 2) && isDeeplyNestedGeneric(target, targetStack, depth)) expandingFlags |= 2;
                 let result: Ternary;
@@ -5150,9 +5153,9 @@ namespace ts {
                 expandingFlags = saveExpandingFlags;
                 depth--;
                 if (result) {
-                    let maybeCache = maybeStack[depth];
+                    const maybeCache = maybeStack[depth];
                     // If result is definitely true, copy assumptions to global cache, else copy to next level up
-                    let destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
+                    const destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
                     copyMap(maybeCache, destinationCache);
                 }
                 else {
@@ -5168,10 +5171,10 @@ namespace ts {
                     return propertiesIdenticalTo(source, target);
                 }
                 let result = Ternary.True;
-                let properties = getPropertiesOfObjectType(target);
-                let requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral);
-                for (let targetProp of properties) {
-                    let sourceProp = getPropertyOfType(source, targetProp.name);
+                const properties = getPropertiesOfObjectType(target);
+                const requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral);
+                for (const targetProp of properties) {
+                    const sourceProp = getPropertyOfType(source, targetProp.name);
 
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
@@ -5183,8 +5186,8 @@ namespace ts {
                             }
                         }
                         else if (!(targetProp.flags & SymbolFlags.Prototype)) {
-                            let sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
-                            let targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
+                            const sourcePropFlags = getDeclarationFlagsFromSymbol(sourceProp);
+                            const targetPropFlags = getDeclarationFlagsFromSymbol(targetProp);
                             if (sourcePropFlags & NodeFlags.Private || targetPropFlags & NodeFlags.Private) {
                                 if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
                                     if (reportErrors) {
@@ -5201,9 +5204,9 @@ namespace ts {
                                 }
                             }
                             else if (targetPropFlags & NodeFlags.Protected) {
-                                let sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & SymbolFlags.Class;
-                                let sourceClass = sourceDeclaredInClass ? <InterfaceType>getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
-                                let targetClass = <InterfaceType>getDeclaredTypeOfSymbol(targetProp.parent);
+                                const sourceDeclaredInClass = sourceProp.parent && sourceProp.parent.flags & SymbolFlags.Class;
+                                const sourceClass = sourceDeclaredInClass ? <InterfaceType>getDeclaredTypeOfSymbol(sourceProp.parent) : undefined;
+                                const targetClass = <InterfaceType>getDeclaredTypeOfSymbol(targetProp.parent);
                                 if (!sourceClass || !hasBaseType(sourceClass, targetClass)) {
                                     if (reportErrors) {
                                         reportError(Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2,
@@ -5219,7 +5222,7 @@ namespace ts {
                                 }
                                 return Ternary.False;
                             }
-                            let related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
+                            const related = isRelatedTo(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp), reportErrors);
                             if (!related) {
                                 if (reportErrors) {
                                     reportError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
@@ -5251,18 +5254,18 @@ namespace ts {
                 if (!(source.flags & TypeFlags.ObjectType && target.flags & TypeFlags.ObjectType)) {
                     return Ternary.False;
                 }
-                let sourceProperties = getPropertiesOfObjectType(source);
-                let targetProperties = getPropertiesOfObjectType(target);
+                const sourceProperties = getPropertiesOfObjectType(source);
+                const targetProperties = getPropertiesOfObjectType(target);
                 if (sourceProperties.length !== targetProperties.length) {
                     return Ternary.False;
                 }
                 let result = Ternary.True;
-                for (let sourceProp of sourceProperties) {
-                    let targetProp = getPropertyOfObjectType(target, sourceProp.name);
+                for (const sourceProp of sourceProperties) {
+                    const targetProp = getPropertyOfObjectType(target, sourceProp.name);
                     if (!targetProp) {
                         return Ternary.False;
                     }
-                    let related = compareProperties(sourceProp, targetProp, isRelatedTo);
+                    const related = compareProperties(sourceProp, targetProp, isRelatedTo);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5278,10 +5281,10 @@ namespace ts {
                 if (target === anyFunctionType || source === anyFunctionType) {
                     return Ternary.True;
                 }
-                let sourceSignatures = getSignaturesOfType(source, kind);
-                let targetSignatures = getSignaturesOfType(target, kind);
+                const sourceSignatures = getSignaturesOfType(source, kind);
+                const targetSignatures = getSignaturesOfType(target, kind);
                 let result = Ternary.True;
-                let saveErrorInfo = errorInfo;
+                const saveErrorInfo = errorInfo;
 
 
 
@@ -5295,8 +5298,8 @@ namespace ts {
                     // sourceSig and targetSig are (possibly) undefined.
                     //
                     // Note that in an extends-clause, targetSignatures is stripped, so the check never proceeds.
-                    let sourceSig = sourceSignatures[0];
-                    let targetSig = targetSignatures[0];
+                    const sourceSig = sourceSignatures[0];
+                    const targetSig = targetSignatures[0];
 
                     result &= abstractSignatureRelatedTo(source, sourceSig, target, targetSig);
                     if (result !== Ternary.True) {
@@ -5304,13 +5307,13 @@ namespace ts {
                     }
                 }
 
-                outer: for (let t of targetSignatures) {
+                outer: for (const t of targetSignatures) {
                     if (!t.hasStringLiterals || target.flags & TypeFlags.FromSignature) {
                         let localErrors = reportErrors;
-                        let checkedAbstractAssignability = false;
-                        for (let s of sourceSignatures) {
+                        const checkedAbstractAssignability = false;
+                        for (const s of sourceSignatures) {
                             if (!s.hasStringLiterals || source.flags & TypeFlags.FromSignature) {
-                                let related = signatureRelatedTo(s, t, localErrors);
+                                const related = signatureRelatedTo(s, t, localErrors);
                                 if (related) {
                                     result &= related;
                                     errorInfo = saveErrorInfo;
@@ -5328,8 +5331,8 @@ namespace ts {
                 function abstractSignatureRelatedTo(source: Type, sourceSig: Signature, target: Type, targetSig: Signature) {
                     if (sourceSig && targetSig) {
 
-                        let sourceDecl = source.symbol && getClassLikeDeclarationOfSymbol(source.symbol);
-                        let targetDecl = target.symbol && getClassLikeDeclarationOfSymbol(target.symbol);
+                        const sourceDecl = source.symbol && getClassLikeDeclarationOfSymbol(source.symbol);
+                        const targetDecl = target.symbol && getClassLikeDeclarationOfSymbol(target.symbol);
 
                         if (!sourceDecl) {
                             // If the source object isn't itself a class declaration, it can be freely assigned, regardless
@@ -5337,16 +5340,16 @@ namespace ts {
                             return Ternary.True;
                         }
 
-                        let sourceErasedSignature = getErasedSignature(sourceSig);
-                        let targetErasedSignature = getErasedSignature(targetSig);
+                        const sourceErasedSignature = getErasedSignature(sourceSig);
+                        const targetErasedSignature = getErasedSignature(targetSig);
 
-                        let sourceReturnType = sourceErasedSignature && getReturnTypeOfSignature(sourceErasedSignature);
-                        let targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
+                        const sourceReturnType = sourceErasedSignature && getReturnTypeOfSignature(sourceErasedSignature);
+                        const targetReturnType = targetErasedSignature && getReturnTypeOfSignature(targetErasedSignature);
 
-                        let sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
-                        let targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
-                        let sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & NodeFlags.Abstract;
-                        let targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & NodeFlags.Abstract;
+                        const sourceReturnDecl = sourceReturnType && sourceReturnType.symbol && getClassLikeDeclarationOfSymbol(sourceReturnType.symbol);
+                        const targetReturnDecl = targetReturnType && targetReturnType.symbol && getClassLikeDeclarationOfSymbol(targetReturnType.symbol);
+                        const sourceIsAbstract = sourceReturnDecl && sourceReturnDecl.flags & NodeFlags.Abstract;
+                        const targetIsAbstract = targetReturnDecl && targetReturnDecl.flags & NodeFlags.Abstract;
 
                         if (sourceIsAbstract && !(targetIsAbstract && targetDecl)) {
                             // if target isn't a class-declaration type, then it can be new'd, so we forbid the assignment.
@@ -5392,9 +5395,9 @@ namespace ts {
                 target = getErasedSignature(target);
                 let result = Ternary.True;
                 for (let i = 0; i < checkCount; i++) {
-                    let s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
-                    let t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
-                    let saveErrorInfo = errorInfo;
+                    const s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
+                    const t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
+                    const saveErrorInfo = errorInfo;
                     let related = isRelatedTo(s, t, reportErrors);
                     if (!related) {
                         related = isRelatedTo(t, s, false);
@@ -5412,16 +5415,16 @@ namespace ts {
                 }
 
                 if (source.typePredicate && target.typePredicate) {
-                    let hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex;
+                    const hasDifferentParameterIndex = source.typePredicate.parameterIndex !== target.typePredicate.parameterIndex;
                     let hasDifferentTypes: boolean;
                     if (hasDifferentParameterIndex ||
                         (hasDifferentTypes = !isTypeIdenticalTo(source.typePredicate.type, target.typePredicate.type))) {
 
                         if (reportErrors) {
-                            let sourceParamText = source.typePredicate.parameterName;
-                            let targetParamText = target.typePredicate.parameterName;
-                            let sourceTypeText = typeToString(source.typePredicate.type);
-                            let targetTypeText = typeToString(target.typePredicate.type);
+                            const sourceParamText = source.typePredicate.parameterName;
+                            const targetParamText = target.typePredicate.parameterName;
+                            const sourceTypeText = typeToString(source.typePredicate.type);
+                            const targetTypeText = typeToString(target.typePredicate.type);
 
                             if (hasDifferentParameterIndex) {
                                 reportError(Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1,
@@ -5448,22 +5451,22 @@ namespace ts {
                     return Ternary.False;
                 }
 
-                let targetReturnType = getReturnTypeOfSignature(target);
+                const targetReturnType = getReturnTypeOfSignature(target);
                 if (targetReturnType === voidType) return result;
-                let sourceReturnType = getReturnTypeOfSignature(source);
+                const sourceReturnType = getReturnTypeOfSignature(source);
 
                 return result & isRelatedTo(sourceReturnType, targetReturnType, reportErrors);
             }
 
             function signaturesIdenticalTo(source: Type, target: Type, kind: SignatureKind): Ternary {
-                let sourceSignatures = getSignaturesOfType(source, kind);
-                let targetSignatures = getSignaturesOfType(target, kind);
+                const sourceSignatures = getSignaturesOfType(source, kind);
+                const targetSignatures = getSignaturesOfType(target, kind);
                 if (sourceSignatures.length !== targetSignatures.length) {
                     return Ternary.False;
                 }
                 let result = Ternary.True;
                 for (let i = 0, len = sourceSignatures.length; i < len; ++i) {
-                    let related = compareSignatures(sourceSignatures[i], targetSignatures[i], /*partialMatch*/ false, /*ignoreReturnTypes*/ false, isRelatedTo);
+                    const related = compareSignatures(sourceSignatures[i], targetSignatures[i], /*partialMatch*/ false, /*ignoreReturnTypes*/ false, isRelatedTo);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5476,21 +5479,21 @@ namespace ts {
                 if (relation === identityRelation) {
                     return indexTypesIdenticalTo(IndexKind.String, source, target);
                 }
-                let targetType = getIndexTypeOfType(target, IndexKind.String);
+                const targetType = getIndexTypeOfType(target, IndexKind.String);
                 if (targetType) {
                     if ((targetType.flags & TypeFlags.Any) && !(originalSource.flags & TypeFlags.Primitive)) {
                         // non-primitive assignment to any is always allowed, eg
                         //   `var x: { [index: string]: any } = { property: 12 };`
                         return Ternary.True;
                     }
-                    let sourceType = getIndexTypeOfType(source, IndexKind.String);
+                    const sourceType = getIndexTypeOfType(source, IndexKind.String);
                     if (!sourceType) {
                         if (reportErrors) {
                             reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
                         }
                         return Ternary.False;
                     }
-                    let related = isRelatedTo(sourceType, targetType, reportErrors);
+                    const related = isRelatedTo(sourceType, targetType, reportErrors);
                     if (!related) {
                         if (reportErrors) {
                             reportError(Diagnostics.Index_signatures_are_incompatible);
@@ -5506,15 +5509,15 @@ namespace ts {
                 if (relation === identityRelation) {
                     return indexTypesIdenticalTo(IndexKind.Number, source, target);
                 }
-                let targetType = getIndexTypeOfType(target, IndexKind.Number);
+                const targetType = getIndexTypeOfType(target, IndexKind.Number);
                 if (targetType) {
                     if ((targetType.flags & TypeFlags.Any) && !(originalSource.flags & TypeFlags.Primitive)) {
                         // non-primitive assignment to any is always allowed, eg
                         //   `var x: { [index: number]: any } = { property: 12 };`
                         return Ternary.True;
                     }
-                    let sourceStringType = getIndexTypeOfType(source, IndexKind.String);
-                    let sourceNumberType = getIndexTypeOfType(source, IndexKind.Number);
+                    const sourceStringType = getIndexTypeOfType(source, IndexKind.String);
+                    const sourceNumberType = getIndexTypeOfType(source, IndexKind.Number);
                     if (!(sourceStringType || sourceNumberType)) {
                         if (reportErrors) {
                             reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
@@ -5541,8 +5544,8 @@ namespace ts {
             }
 
             function indexTypesIdenticalTo(indexKind: IndexKind, source: Type, target: Type): Ternary {
-                let targetType = getIndexTypeOfType(target, indexKind);
-                let sourceType = getIndexTypeOfType(source, indexKind);
+                const targetType = getIndexTypeOfType(target, indexKind);
+                const sourceType = getIndexTypeOfType(source, indexKind);
                 if (!sourceType && !targetType) {
                     return Ternary.True;
                 }
@@ -5561,10 +5564,10 @@ namespace ts {
         function isDeeplyNestedGeneric(type: Type, stack: Type[], depth: number): boolean {
             // We track type references (created by createTypeReference) and instantiated types (created by instantiateType)
             if (type.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && depth >= 5) {
-                let symbol = type.symbol;
+                const symbol = type.symbol;
                 let count = 0;
                 for (let i = 0; i < depth; i++) {
-                    let t = stack[i];
+                    const t = stack[i];
                     if (t.flags & (TypeFlags.Reference | TypeFlags.Instantiated) && t.symbol === symbol) {
                         count++;
                         if (count >= 5) return true;
@@ -5585,8 +5588,8 @@ namespace ts {
             if (sourceProp === targetProp) {
                 return Ternary.True;
             }
-            let sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (NodeFlags.Private | NodeFlags.Protected);
-            let targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (NodeFlags.Private | NodeFlags.Protected);
+            const sourcePropAccessibility = getDeclarationFlagsFromSymbol(sourceProp) & (NodeFlags.Private | NodeFlags.Protected);
+            const targetPropAccessibility = getDeclarationFlagsFromSymbol(targetProp) & (NodeFlags.Private | NodeFlags.Protected);
             if (sourcePropAccessibility !== targetPropAccessibility) {
                 return Ternary.False;
             }
@@ -5603,18 +5606,31 @@ namespace ts {
             return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
         }
 
+        function isMatchingSignature(source: Signature, target: Signature, partialMatch: boolean) {
+            // A source signature matches a target signature if the two signatures have the same number of required,
+            // optional, and rest parameters.
+            if (source.parameters.length === target.parameters.length &&
+                source.minArgumentCount === target.minArgumentCount &&
+                source.hasRestParameter === target.hasRestParameter) {
+                return true;
+            }
+            // A source signature partially matches a target signature if the target signature has no fewer required
+            // parameters and no more overall parameters than the source signature (where a signature with a rest
+            // parameter is always considered to have more overall parameters than one without).
+            if (partialMatch && source.minArgumentCount <= target.minArgumentCount && (
+                source.hasRestParameter && !target.hasRestParameter ||
+                source.hasRestParameter === target.hasRestParameter && source.parameters.length >= target.parameters.length)) {
+                return true;
+            }
+            return false;
+        }
+
         function compareSignatures(source: Signature, target: Signature, partialMatch: boolean, ignoreReturnTypes: boolean, compareTypes: (s: Type, t: Type) => Ternary): Ternary {
             if (source === target) {
                 return Ternary.True;
             }
-            if (source.parameters.length !== target.parameters.length ||
-                source.minArgumentCount !== target.minArgumentCount ||
-                source.hasRestParameter !== target.hasRestParameter) {
-                if (!partialMatch ||
-                    source.parameters.length < target.parameters.length && !source.hasRestParameter ||
-                    source.minArgumentCount > target.minArgumentCount) {
-                    return Ternary.False;
-                }
+            if (!(isMatchingSignature(source, target, partialMatch))) {
+                return Ternary.False;
             }
             let result = Ternary.True;
             if (source.typeParameters && target.typeParameters) {
@@ -5622,7 +5638,7 @@ namespace ts {
                     return Ternary.False;
                 }
                 for (let i = 0, len = source.typeParameters.length; i < len; ++i) {
-                    let related = compareTypes(source.typeParameters[i], target.typeParameters[i]);
+                    const related = compareTypes(source.typeParameters[i], target.typeParameters[i]);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5636,11 +5652,11 @@ namespace ts {
             // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
             source = getErasedSignature(source);
             target = getErasedSignature(target);
-            let targetLen = target.parameters.length;
+            const targetLen = target.parameters.length;
             for (let i = 0; i < targetLen; i++) {
-                let s = isRestParameterIndex(source, i) ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
-                let t = isRestParameterIndex(target, i) ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
-                let related = compareTypes(s, t);
+                const s = isRestParameterIndex(source, i) ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
+                const t = isRestParameterIndex(target, i) ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
+                const related = compareTypes(s, t);
                 if (!related) {
                     return Ternary.False;
                 }
@@ -5657,7 +5673,7 @@ namespace ts {
         }
 
         function isSupertypeOfEach(candidate: Type, types: Type[]): boolean {
-            for (let type of types) {
+            for (const type of types) {
                 if (candidate !== type && !isTypeSubtypeOf(type, candidate)) return false;
             }
             return true;
@@ -5749,13 +5765,13 @@ namespace ts {
         }
 
         function getWidenedTypeOfObjectLiteral(type: Type): Type {
-            let properties = getPropertiesOfObjectType(type);
-            let members: SymbolTable = {};
+            const properties = getPropertiesOfObjectType(type);
+            const members: SymbolTable = {};
             forEach(properties, p => {
-                let propType = getTypeOfSymbol(p);
-                let widenedType = getWidenedType(propType);
+                const propType = getTypeOfSymbol(p);
+                const widenedType = getWidenedType(propType);
                 if (propType !== widenedType) {
-                    let symbol = <TransientSymbol>createSymbol(p.flags | SymbolFlags.Transient, p.name);
+                    const symbol = <TransientSymbol>createSymbol(p.flags | SymbolFlags.Transient, p.name);
                     symbol.declarations = p.declarations;
                     symbol.parent = p.parent;
                     symbol.type = widenedType;
@@ -5807,7 +5823,7 @@ namespace ts {
         function reportWideningErrorsInType(type: Type): boolean {
             let errorReported = false;
             if (type.flags & TypeFlags.Union) {
-                for (let t of (<UnionType>type).types) {
+                for (const t of (<UnionType>type).types) {
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
                     }
@@ -5817,15 +5833,15 @@ namespace ts {
                 return reportWideningErrorsInType((<TypeReference>type).typeArguments[0]);
             }
             if (isTupleType(type)) {
-                for (let t of type.elementTypes) {
+                for (const t of type.elementTypes) {
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
                     }
                 }
             }
             if (type.flags & TypeFlags.ObjectLiteral) {
-                for (let p of getPropertiesOfObjectType(type)) {
-                    let t = getTypeOfSymbol(p);
+                for (const p of getPropertiesOfObjectType(type)) {
+                    const t = getTypeOfSymbol(p);
                     if (t.flags & TypeFlags.ContainsUndefinedOrNull) {
                         if (!reportWideningErrorsInType(t)) {
                             error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t)));
@@ -5838,7 +5854,7 @@ namespace ts {
         }
 
         function reportImplicitAnyError(declaration: Declaration, type: Type) {
-            let typeAsString = typeToString(getWidenedType(type));
+            const typeAsString = typeToString(getWidenedType(type));
             let diagnostic: DiagnosticMessage;
             switch (declaration.kind) {
                 case SyntaxKind.PropertyDeclaration:
@@ -5899,15 +5915,15 @@ namespace ts {
                 count = sourceMax < targetMax ? sourceMax : targetMax;
             }
             for (let i = 0; i < count; i++) {
-                let s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
-                let t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
+                const s = i < sourceMax ? getTypeOfSymbol(source.parameters[i]) : getRestTypeOfSignature(source);
+                const t = i < targetMax ? getTypeOfSymbol(target.parameters[i]) : getRestTypeOfSignature(target);
                 callback(s, t);
             }
         }
 
         function createInferenceContext(typeParameters: TypeParameter[], inferUnionTypes: boolean): InferenceContext {
-            let inferences: TypeInferences[] = [];
-            for (let unused of typeParameters) {
+            const inferences: TypeInferences[] = [];
+            for (const unused of typeParameters) {
                 inferences.push({
                     primary: undefined, secondary: undefined, isFixed: false
                 });
@@ -5948,10 +5964,10 @@ namespace ts {
                         return;
                     }
 
-                    let typeParameters = context.typeParameters;
+                    const typeParameters = context.typeParameters;
                     for (let i = 0; i < typeParameters.length; i++) {
                         if (target === typeParameters[i]) {
-                            let inferences = context.inferences[i];
+                            const inferences = context.inferences[i];
                             if (!inferences.isFixed) {
                                 // Any inferences that are made to a type parameter in a union type are inferior
                                 // to inferences made to a flat (non-union) type. This is because if we infer to
@@ -5959,7 +5975,7 @@ namespace ts {
                                 // the correct constituent on the target side could be string[]). Therefore, we put
                                 // such inferior inferences into a secondary bucket, and only use them if the primary
                                 // bucket is empty.
-                                let candidates = inferiority ?
+                                const candidates = inferiority ?
                                     inferences.secondary || (inferences.secondary = []) :
                                     inferences.primary || (inferences.primary = []);
                                 if (!contains(candidates, source)) {
@@ -5972,27 +5988,27 @@ namespace ts {
                 }
                 else if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (<TypeReference>source).target === (<TypeReference>target).target) {
                     // If source and target are references to the same generic type, infer from type arguments
-                    let sourceTypes = (<TypeReference>source).typeArguments || emptyArray;
-                    let targetTypes = (<TypeReference>target).typeArguments || emptyArray;
-                    let count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
+                    const sourceTypes = (<TypeReference>source).typeArguments || emptyArray;
+                    const targetTypes = (<TypeReference>target).typeArguments || emptyArray;
+                    const count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
                     for (let i = 0; i < count; i++) {
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
                 else if (source.flags & TypeFlags.Tuple && target.flags & TypeFlags.Tuple && (<TupleType>source).elementTypes.length === (<TupleType>target).elementTypes.length) {
                     // If source and target are tuples of the same size, infer from element types
-                    let sourceTypes = (<TupleType>source).elementTypes;
-                    let targetTypes = (<TupleType>target).elementTypes;
+                    const sourceTypes = (<TupleType>source).elementTypes;
+                    const targetTypes = (<TupleType>target).elementTypes;
                     for (let i = 0; i < sourceTypes.length; i++) {
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
                 else if (target.flags & TypeFlags.UnionOrIntersection) {
-                    let targetTypes = (<UnionOrIntersectionType>target).types;
+                    const targetTypes = (<UnionOrIntersectionType>target).types;
                     let typeParameterCount = 0;
                     let typeParameter: TypeParameter;
                     // First infer to each type in union or intersection that isn't a type parameter
-                    for (let t of targetTypes) {
+                    for (const t of targetTypes) {
                         if (t.flags & TypeFlags.TypeParameter && contains(context.typeParameters, t)) {
                             typeParameter = <TypeParameter>t;
                             typeParameterCount++;
@@ -6013,8 +6029,8 @@ namespace ts {
                 }
                 else if (source.flags & TypeFlags.UnionOrIntersection) {
                     // Source is a union or intersection type, infer from each consituent type
-                    let sourceTypes = (<UnionOrIntersectionType>source).types;
-                    for (let sourceType of sourceTypes) {
+                    const sourceTypes = (<UnionOrIntersectionType>source).types;
+                    for (const sourceType of sourceTypes) {
                         inferFromTypes(sourceType, target);
                     }
                 }
@@ -6049,9 +6065,9 @@ namespace ts {
             }
 
             function inferFromProperties(source: Type, target: Type) {
-                let properties = getPropertiesOfObjectType(target);
-                for (let targetProp of properties) {
-                    let sourceProp = getPropertyOfObjectType(source, targetProp.name);
+                const properties = getPropertiesOfObjectType(target);
+                for (const targetProp of properties) {
+                    const sourceProp = getPropertyOfObjectType(source, targetProp.name);
                     if (sourceProp) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
                     }
@@ -6059,11 +6075,11 @@ namespace ts {
             }
 
             function inferFromSignatures(source: Type, target: Type, kind: SignatureKind) {
-                let sourceSignatures = getSignaturesOfType(source, kind);
-                let targetSignatures = getSignaturesOfType(target, kind);
-                let sourceLen = sourceSignatures.length;
-                let targetLen = targetSignatures.length;
-                let len = sourceLen < targetLen ? sourceLen : targetLen;
+                const sourceSignatures = getSignaturesOfType(source, kind);
+                const targetSignatures = getSignaturesOfType(target, kind);
+                const sourceLen = sourceSignatures.length;
+                const targetLen = targetSignatures.length;
+                const len = sourceLen < targetLen ? sourceLen : targetLen;
                 for (let i = 0; i < len; i++) {
                     inferFromSignature(getErasedSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
                 }
@@ -6085,9 +6101,9 @@ namespace ts {
             }
 
             function inferFromIndexTypes(source: Type, target: Type, sourceKind: IndexKind, targetKind: IndexKind) {
-                let targetIndexType = getIndexTypeOfType(target, targetKind);
+                const targetIndexType = getIndexTypeOfType(target, targetKind);
                 if (targetIndexType) {
-                    let sourceIndexType = getIndexTypeOfType(source, sourceKind);
+                    const sourceIndexType = getIndexTypeOfType(source, sourceKind);
                     if (sourceIndexType) {
                         inferFromTypes(sourceIndexType, targetIndexType);
                     }
@@ -6096,7 +6112,7 @@ namespace ts {
         }
 
         function getInferenceCandidates(context: InferenceContext, index: number): Type[] {
-            let inferences = context.inferences[index];
+            const inferences = context.inferences[index];
             return inferences.primary || inferences.secondary || emptyArray;
         }
 
@@ -6104,10 +6120,10 @@ namespace ts {
             let inferredType = context.inferredTypes[index];
             let inferenceSucceeded: boolean;
             if (!inferredType) {
-                let inferences = getInferenceCandidates(context, index);
+                const inferences = getInferenceCandidates(context, index);
                 if (inferences.length) {
                     // Infer widened union or supertype, or the unknown type for no common supertype
-                    let unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
+                    const unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences) : getCommonSupertype(inferences);
                     inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : unknownType;
                     inferenceSucceeded = !!unionOrSuperType;
                 }
@@ -6122,7 +6138,7 @@ namespace ts {
 
                 // Only do the constraint check if inference succeeded (to prevent cascading errors)
                 if (inferenceSucceeded) {
-                    let constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
+                    const constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
                     inferredType = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType;
                 }
                 else if (context.failedTypeParameterIndex === undefined || context.failedTypeParameterIndex > index) {
@@ -6151,7 +6167,7 @@ namespace ts {
         // EXPRESSION TYPE CHECKING
 
         function getResolvedSymbol(node: Identifier): Symbol {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
                 links.resolvedSymbol = (!nodeIsMissing(node) && resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, node)) || unknownSymbol;
             }
@@ -6181,10 +6197,10 @@ namespace ts {
         // or not of the given type kind (when isOfTypeKind is false)
         function removeTypesFromUnionType(type: Type, typeKind: TypeFlags, isOfTypeKind: boolean, allowEmptyUnionResult: boolean): Type {
             if (type.flags & TypeFlags.Union) {
-                let types = (<UnionType>type).types;
+                const types = (<UnionType>type).types;
                 if (forEach(types, t => !!(t.flags & typeKind) === isOfTypeKind)) {
                     // Above we checked if we have anything to remove, now use the opposite test to do the removal
-                    let narrowedType = getUnionType(filter(types, t => !(t.flags & typeKind) === isOfTypeKind));
+                    const narrowedType = getUnionType(filter(types, t => !(t.flags & typeKind) === isOfTypeKind));
                     if (allowEmptyUnionResult || narrowedType !== emptyObjectType) {
                         return narrowedType;
                     }
@@ -6204,9 +6220,9 @@ namespace ts {
 
         // Check if a given variable is assigned within a given syntax node
         function isVariableAssignedWithin(symbol: Symbol, node: Node): boolean {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (links.assignmentChecks) {
-                let cachedResult = links.assignmentChecks[symbol.id];
+                const cachedResult = links.assignmentChecks[symbol.id];
                 if (cachedResult !== undefined) {
                     return cachedResult;
                 }
@@ -6300,7 +6316,7 @@ namespace ts {
             if (node && symbol.flags & SymbolFlags.Variable) {
                 if (isTypeAny(type) || type.flags & (TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) {
                     loop: while (node.parent) {
-                        let child = node;
+                        const child = node;
                         node = node.parent;
                         let narrowedType = type;
                         switch (node.kind) {
@@ -6356,12 +6372,12 @@ namespace ts {
                 if (expr.left.kind !== SyntaxKind.TypeOfExpression || expr.right.kind !== SyntaxKind.StringLiteral) {
                     return type;
                 }
-                let left = <TypeOfExpression>expr.left;
-                let right = <LiteralExpression>expr.right;
+                const left = <TypeOfExpression>expr.left;
+                const right = <LiteralExpression>expr.right;
                 if (left.expression.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>left.expression) !== symbol) {
                     return type;
                 }
-                let typeInfo = primitiveTypeInfo[right.text];
+                const typeInfo = primitiveTypeInfo[right.text];
                 if (expr.operatorToken.kind === SyntaxKind.ExclamationEqualsEqualsToken) {
                     assumeTrue = !assumeTrue;
                 }
@@ -6425,16 +6441,16 @@ namespace ts {
                     return type;
                 }
                 // Check that right operand is a function type with a prototype property
-                let rightType = checkExpression(expr.right);
+                const rightType = checkExpression(expr.right);
                 if (!isTypeSubtypeOf(rightType, globalFunctionType)) {
                     return type;
                 }
 
                 let targetType: Type;
-                let prototypeProperty = getPropertyOfType(rightType, "prototype");
+                const prototypeProperty = getPropertyOfType(rightType, "prototype");
                 if (prototypeProperty) {
                     // Target type is type of the prototype property
-                    let prototypePropertyType = getTypeOfSymbol(prototypeProperty);
+                    const prototypePropertyType = getTypeOfSymbol(prototypeProperty);
                     if (!isTypeAny(prototypePropertyType)) {
                         targetType = prototypePropertyType;
                     }
@@ -6465,7 +6481,7 @@ namespace ts {
                 // If the current type is a union type, remove all constituents that aren't assignable to target. If that produces
                 // 0 candidates, fall back to the assignability check
                 if (originalType.flags & TypeFlags.Union) {
-                    let assignableConstituents = filter((<UnionType>originalType).types, t => isTypeAssignableTo(t, narrowedTypeCandidate));
+                    const assignableConstituents = filter((<UnionType>originalType).types, t => isTypeAssignableTo(t, narrowedTypeCandidate));
                     if (assignableConstituents.length) {
                         return getUnionType(assignableConstituents);
                     }
@@ -6483,7 +6499,7 @@ namespace ts {
                 if (type.flags & TypeFlags.Any) {
                     return type;
                 }
-                let signature = getResolvedSignature(expr);
+                const signature = getResolvedSignature(expr);
 
                 if (signature.typePredicate &&
                     expr.arguments[signature.typePredicate.parameterIndex] &&
@@ -6509,7 +6525,7 @@ namespace ts {
                     case SyntaxKind.ParenthesizedExpression:
                         return narrowType(type, (<ParenthesizedExpression>expr).expression, assumeTrue);
                     case SyntaxKind.BinaryExpression:
-                        let operator = (<BinaryExpression>expr).operatorToken.kind;
+                        const operator = (<BinaryExpression>expr).operatorToken.kind;
                         if (operator === SyntaxKind.EqualsEqualsEqualsToken || operator === SyntaxKind.ExclamationEqualsEqualsToken) {
                             return narrowTypeByEquality(type, <BinaryExpression>expr, assumeTrue);
                         }
@@ -6534,7 +6550,7 @@ namespace ts {
         }
 
         function checkIdentifier(node: Identifier): Type {
-            let symbol = getResolvedSymbol(node);
+            const symbol = getResolvedSymbol(node);
 
             // As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects.
             // Although in down-level emit of arrow function, we emit it using function expression which means that
@@ -6543,7 +6559,7 @@ namespace ts {
             // To avoid that we will give an error to users if they use arguments objects in arrow function so that they
             // can explicitly bound arguments objects
             if (symbol === argumentsSymbol) {
-                let container = getContainingFunction(node);
+                const container = getContainingFunction(node);
                 if (container.kind === SyntaxKind.ArrowFunction) {
                     if (languageVersion < ScriptTarget.ES6) {
                         error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
@@ -6611,7 +6627,7 @@ namespace ts {
                 }
             }
 
-            let inFunction = isInsideFunction(node.parent, container);
+            const inFunction = isInsideFunction(node.parent, container);
 
             let current = container;
             while (current && !nodeStartsNewLexicalEnvironment(current)) {
@@ -6630,7 +6646,7 @@ namespace ts {
         function captureLexicalThis(node: Node, container: Node): void {
             getNodeLinks(node).flags |= NodeCheckFlags.LexicalThis;
             if (container.kind === SyntaxKind.PropertyDeclaration || container.kind === SyntaxKind.Constructor) {
-                let classNode = container.parent;
+                const classNode = container.parent;
                 getNodeLinks(classNode).flags |= NodeCheckFlags.CaptureThis;
             }
             else {
@@ -6684,7 +6700,7 @@ namespace ts {
             }
 
             if (isClassLike(container.parent)) {
-                let symbol = getSymbolOfNode(container.parent);
+                const symbol = getSymbolOfNode(container.parent);
                 return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : (<InterfaceType>getDeclaredTypeOfSymbol(symbol)).thisType;
             }
             return anyType;
@@ -6700,10 +6716,10 @@ namespace ts {
         }
 
         function checkSuperExpression(node: Node): Type {
-            let isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
-            let classDeclaration = getContainingClass(node);
-            let classType = classDeclaration && <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration));
-            let baseClassType = classType && getBaseTypes(classType)[0];
+            const isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
+            const classDeclaration = getContainingClass(node);
+            const classType = classDeclaration && <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration));
+            const baseClassType = classType && getBaseTypes(classType)[0];
 
             let container = getSuperContainer(node, /*includeFunctions*/ true);
             let needToCaptureLexicalThis = false;
@@ -6716,7 +6732,7 @@ namespace ts {
                 }
             }
 
-            let canUseSuperExpression = isLegalUsageOfSuperExpression(container);
+            const canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             let nodeCheckFlag: NodeCheckFlags = 0;
 
             // always set NodeCheckFlags for 'super' expression node
@@ -6811,15 +6827,15 @@ namespace ts {
 
         // Return contextual type of parameter or undefined if no contextual type is available
         function getContextuallyTypedParameterType(parameter: ParameterDeclaration): Type {
-            let func = parameter.parent;
+            const func = parameter.parent;
             if (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) {
                 if (isContextSensitive(func)) {
-                    let contextualSignature = getContextualSignature(func);
+                    const contextualSignature = getContextualSignature(func);
                     if (contextualSignature) {
 
-                        let funcHasRestParameters = hasRestParameter(func);
-                        let len = func.parameters.length - (funcHasRestParameters ? 1 : 0);
-                        let indexOfParameter = indexOf(func.parameters, parameter);
+                        const funcHasRestParameters = hasRestParameter(func);
+                        const len = func.parameters.length - (funcHasRestParameters ? 1 : 0);
+                        const indexOfParameter = indexOf(func.parameters, parameter);
                         if (indexOfParameter < len) {
                             return getTypeAtPosition(contextualSignature, indexOfParameter);
                         }
@@ -6842,13 +6858,13 @@ namespace ts {
         // of the parameter. Otherwise, in a variable or parameter declaration with a binding pattern name, the contextual
         // type of an initializer expression is the type implied by the binding pattern.
         function getContextualTypeForInitializerExpression(node: Expression): Type {
-            let declaration = <VariableLikeDeclaration>node.parent;
+            const declaration = <VariableLikeDeclaration>node.parent;
             if (node === declaration.initializer) {
                 if (declaration.type) {
                     return getTypeFromTypeNode(declaration.type);
                 }
                 if (declaration.kind === SyntaxKind.Parameter) {
-                    let type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                    const type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
                     if (type) {
                         return type;
                     }
@@ -6861,7 +6877,7 @@ namespace ts {
         }
 
         function getContextualTypeForReturnExpression(node: Expression): Type {
-            let func = getContainingFunction(node);
+            const func = getContainingFunction(node);
             if (func && !func.asteriskToken) {
                 return getContextualReturnType(func);
             }
@@ -6870,9 +6886,9 @@ namespace ts {
         }
 
         function getContextualTypeForYieldOperand(node: YieldExpression): Type {
-            let func = getContainingFunction(node);
+            const func = getContainingFunction(node);
             if (func) {
-                let contextualReturnType = getContextualReturnType(func);
+                const contextualReturnType = getContextualReturnType(func);
                 if (contextualReturnType) {
                     return node.asteriskToken
                         ? contextualReturnType
@@ -6906,7 +6922,7 @@ namespace ts {
 
             // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature
             // and that call signature is non-generic, return statements are contextually typed by the return type of the signature
-            let signature = getContextualSignatureForFunctionLikeDeclaration(<FunctionExpression>functionDecl);
+            const signature = getContextualSignatureForFunctionLikeDeclaration(<FunctionExpression>functionDecl);
             if (signature) {
                 return getReturnTypeOfSignature(signature);
             }
@@ -6916,10 +6932,10 @@ namespace ts {
 
         // In a typed function call, an argument or substitution expression is contextually typed by the type of the corresponding parameter.
         function getContextualTypeForArgument(callTarget: CallLikeExpression, arg: Expression): Type {
-            let args = getEffectiveCallArguments(callTarget);
-            let argIndex = indexOf(args, arg);
+            const args = getEffectiveCallArguments(callTarget);
+            const argIndex = indexOf(args, arg);
             if (argIndex >= 0) {
-                let signature = getResolvedSignature(callTarget);
+                const signature = getResolvedSignature(callTarget);
                 return getTypeAtPosition(signature, argIndex);
             }
             return undefined;
@@ -6934,8 +6950,8 @@ namespace ts {
         }
 
         function getContextualTypeForBinaryOperand(node: Expression): Type {
-            let binaryExpression = <BinaryExpression>node.parent;
-            let operator = binaryExpression.operatorToken.kind;
+            const binaryExpression = <BinaryExpression>node.parent;
+            const operator = binaryExpression.operatorToken.kind;
             if (operator >= SyntaxKind.FirstAssignment && operator <= SyntaxKind.LastAssignment) {
                 // In an assignment expression, the right operand is contextually typed by the type of the left operand.
                 if (node === binaryExpression.right) {
@@ -6961,11 +6977,11 @@ namespace ts {
             if (!(type.flags & TypeFlags.Union)) {
                 return mapper(type);
             }
-            let types = (<UnionType>type).types;
+            const types = (<UnionType>type).types;
             let mappedType: Type;
             let mappedTypes: Type[];
-            for (let current of types) {
-                let t = mapper(current);
+            for (const current of types) {
+                const t = mapper(current);
                 if (t) {
                     if (!mappedType) {
                         mappedType = t;
@@ -6983,7 +6999,7 @@ namespace ts {
 
         function getTypeOfPropertyOfContextualType(type: Type, name: string) {
             return applyToContextualType(type, t => {
-                let prop = t.flags & TypeFlags.StructuredType ? getPropertyOfType(t, name) : undefined;
+                const prop = t.flags & TypeFlags.StructuredType ? getPropertyOfType(t, name) : undefined;
                 return prop ? getTypeOfSymbol(prop) : undefined;
             });
         }
@@ -7016,15 +7032,15 @@ namespace ts {
         }
 
         function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElement) {
-            let objectLiteral = <ObjectLiteralExpression>element.parent;
-            let type = getContextualType(objectLiteral);
+            const objectLiteral = <ObjectLiteralExpression>element.parent;
+            const type = getContextualType(objectLiteral);
             if (type) {
                 if (!hasDynamicName(element)) {
                     // For a (non-symbol) computed property, there is no reason to look up the name
                     // in the type. It will just be "__computed", which does not appear in any
                     // SymbolTable.
-                    let symbolName = getSymbolOfNode(element).name;
-                    let propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
+                    const symbolName = getSymbolOfNode(element).name;
+                    const propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
                     if (propertyType) {
                         return propertyType;
                     }
@@ -7042,10 +7058,10 @@ namespace ts {
         // it is the type of the numeric index signature in T. Otherwise, in ES6 and higher, the contextual type is the iterated
         // type of T.
         function getContextualTypeForElementExpression(node: Expression): Type {
-            let arrayLiteral = <ArrayLiteralExpression>node.parent;
-            let type = getContextualType(arrayLiteral);
+            const arrayLiteral = <ArrayLiteralExpression>node.parent;
+            const type = getContextualType(arrayLiteral);
             if (type) {
-                let index = indexOf(arrayLiteral.elements, node);
+                const index = indexOf(arrayLiteral.elements, node);
                 return getTypeOfPropertyOfContextualType(type, "" + index)
                     || getIndexTypeOfContextualType(type, IndexKind.Number)
                     || (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(type, /*errorNode*/ undefined) : undefined);
@@ -7055,15 +7071,15 @@ namespace ts {
 
         // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type.
         function getContextualTypeForConditionalOperand(node: Expression): Type {
-            let conditional = <ConditionalExpression>node.parent;
+            const conditional = <ConditionalExpression>node.parent;
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined;
         }
 
         function getContextualTypeForJsxExpression(expr: JsxExpression | JsxSpreadAttribute): Type {
             // Contextual type only applies to JSX expressions that are in attribute assignments (not in 'Children' positions)
             if (expr.parent.kind === SyntaxKind.JsxAttribute) {
-                let attrib = <JsxAttribute>expr.parent;
-                let attrsType = getJsxElementAttributesType(<JsxOpeningLikeElement>attrib.parent);
+                const attrib = <JsxAttribute>expr.parent;
+                const attrsType = getJsxElementAttributesType(<JsxOpeningLikeElement>attrib.parent);
                 if (!attrsType || isTypeAny(attrsType)) {
                     return undefined;
                 }
@@ -7082,7 +7098,7 @@ namespace ts {
         // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily
         // be "pushed" onto a node using the contextualType property.
         function getContextualType(node: Expression): Type {
-            let type = getContextualTypeWorker(node);
+            const type = getContextualTypeWorker(node);
             return type && getApparentType(type);
         }
 
@@ -7094,7 +7110,7 @@ namespace ts {
             if (node.contextualType) {
                 return node.contextualType;
             }
-            let parent = node.parent;
+            const parent = node.parent;
             switch (parent.kind) {
                 case SyntaxKind.VariableDeclaration:
                 case SyntaxKind.Parameter:
@@ -7136,9 +7152,9 @@ namespace ts {
         // If the given type is an object or union type, if that type has a single signature, and if
         // that signature is non-generic, return the signature. Otherwise return undefined.
         function getNonGenericSignature(type: Type): Signature {
-            let signatures = getSignaturesOfStructuredType(type, SignatureKind.Call);
+            const signatures = getSignaturesOfStructuredType(type, SignatureKind.Call);
             if (signatures.length === 1) {
-                let signature = signatures[0];
+                const signature = signatures[0];
                 if (!signature.typeParameters) {
                     return signature;
                 }
@@ -7163,7 +7179,7 @@ namespace ts {
         // union type of return types from these signatures
         function getContextualSignature(node: FunctionExpression | MethodDeclaration): Signature {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
-            let type = isObjectLiteralMethod(node)
+            const type = isObjectLiteralMethod(node)
                 ? getContextualTypeForObjectLiteralMethod(node)
                 : getContextualType(node);
             if (!type) {
@@ -7173,9 +7189,9 @@ namespace ts {
                 return getNonGenericSignature(type);
             }
             let signatureList: Signature[];
-            let types = (<UnionType>type).types;
-            for (let current of types) {
-                let signature = getNonGenericSignature(current);
+            const types = (<UnionType>type).types;
+            for (const current of types) {
+                const signature = getNonGenericSignature(current);
                 if (signature) {
                     if (!signatureList) {
                         // This signature will contribute to contextual union signature
@@ -7226,7 +7242,7 @@ namespace ts {
         // assignment in an object literal that is an assignment target, or if it is parented by an array literal that is
         // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ p: a}] = xxx'.
         function isAssignmentTarget(node: Node): boolean {
-            let parent = node.parent;
+            const parent = node.parent;
             if (parent.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>parent).operatorToken.kind === SyntaxKind.EqualsToken && (<BinaryExpression>parent).left === node) {
                 return true;
             }
@@ -7246,7 +7262,7 @@ namespace ts {
             // with this type. It is neither affected by it, nor does it propagate it to its operand.
             // So the fact that contextualMapper is passed is not important, because the operand of a spread
             // element is not contextually typed.
-            let arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper);
+            const arrayOrIterableType = checkExpressionCached(node.expression, contextualMapper);
             return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false);
         }
 
@@ -7256,11 +7272,11 @@ namespace ts {
         }
 
         function checkArrayLiteral(node: ArrayLiteralExpression, contextualMapper?: TypeMapper): Type {
-            let elements = node.elements;
+            const elements = node.elements;
             let hasSpreadElement = false;
-            let elementTypes: Type[] = [];
-            let inDestructuringPattern = isAssignmentTarget(node);
-            for (let e of elements) {
+            const elementTypes: Type[] = [];
+            const inDestructuringPattern = isAssignmentTarget(node);
+            for (const e of elements) {
                 if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElementExpression) {
                     // Given the following situation:
                     //    var c: {};
@@ -7274,15 +7290,15 @@ namespace ts {
                     // get the contextual element type from it. So we do something similar to
                     // getContextualTypeForElementExpression, which will crucially not error
                     // if there is no index type / iterated type.
-                    let restArrayType = checkExpression((<SpreadElementExpression>e).expression, contextualMapper);
-                    let restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
+                    const restArrayType = checkExpression((<SpreadElementExpression>e).expression, contextualMapper);
+                    const restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
                         (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
                     if (restElementType) {
                         elementTypes.push(restElementType);
                     }
                 }
                 else {
-                    let type = checkExpression(e, contextualMapper);
+                    const type = checkExpression(e, contextualMapper);
                     elementTypes.push(type);
                 }
                 hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
@@ -7291,19 +7307,19 @@ namespace ts {
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
                 // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
                 if (inDestructuringPattern && elementTypes.length) {
-                    let type = createNewTupleType(elementTypes);
+                    const type = createNewTupleType(elementTypes);
                     type.pattern = node;
                     return type;
                 }
-                let contextualType = getContextualType(node);
+                const contextualType = getContextualType(node);
                 if (contextualType && contextualTypeIsTupleLikeType(contextualType)) {
-                    let pattern = contextualType.pattern;
+                    const pattern = contextualType.pattern;
                     // If array literal is contextually typed by a binding pattern or an assignment pattern, pad the resulting
                     // tuple type with the corresponding binding or assignment element types to make the lengths equal.
                     if (pattern && (pattern.kind === SyntaxKind.ArrayBindingPattern || pattern.kind === SyntaxKind.ArrayLiteralExpression)) {
-                        let patternElements = (<BindingPattern | ArrayLiteralExpression>pattern).elements;
+                        const patternElements = (<BindingPattern | ArrayLiteralExpression>pattern).elements;
                         for (let i = elementTypes.length; i < patternElements.length; i++) {
-                            let patternElement = patternElements[i];
+                            const patternElement = patternElements[i];
                             if (hasDefaultValue(patternElement)) {
                                 elementTypes.push((<TupleType>contextualType).elementTypes[i]);
                             }
@@ -7363,7 +7379,7 @@ namespace ts {
         }
 
         function checkComputedPropertyName(node: ComputedPropertyName): Type {
-            let links = getNodeLinks(node.expression);
+            const links = getNodeLinks(node.expression);
             if (!links.resolvedType) {
                 links.resolvedType = checkExpression(node.expression);
 
@@ -7381,18 +7397,18 @@ namespace ts {
         }
 
         function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type {
-            let inDestructuringPattern = isAssignmentTarget(node);
+            const inDestructuringPattern = isAssignmentTarget(node);
             // Grammar checking
             checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
 
-            let propertiesTable: SymbolTable = {};
-            let propertiesArray: Symbol[] = [];
-            let contextualType = getContextualType(node);
-            let contextualTypeHasPattern = contextualType && contextualType.pattern &&
+            const propertiesTable: SymbolTable = {};
+            const propertiesArray: Symbol[] = [];
+            const contextualType = getContextualType(node);
+            const contextualTypeHasPattern = contextualType && contextualType.pattern &&
                 (contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression);
             let typeFlags: TypeFlags = 0;
 
-            for (let memberDecl of node.properties) {
+            for (const memberDecl of node.properties) {
                 let member = memberDecl.symbol;
                 if (memberDecl.kind === SyntaxKind.PropertyAssignment ||
                     memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment ||
@@ -7409,7 +7425,7 @@ namespace ts {
                         type = checkExpression((<ShorthandPropertyAssignment>memberDecl).name, contextualMapper);
                     }
                     typeFlags |= type.flags;
-                    let prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
+                    const prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
                     if (inDestructuringPattern) {
                         // If object literal is an assignment pattern and if the assignment pattern specifies a default value
                         // for the property, make the property optional.
@@ -7423,7 +7439,7 @@ namespace ts {
                     else if (contextualTypeHasPattern) {
                         // If object literal is contextually typed by the implied type of a binding pattern, and if the
                         // binding pattern specifies a default value for the property, make the property optional.
-                        let impliedProp = getPropertyOfType(contextualType, member.name);
+                        const impliedProp = getPropertyOfType(contextualType, member.name);
                         if (impliedProp) {
                             prop.flags |= impliedProp.flags & SymbolFlags.Optional;
                         }
@@ -7461,7 +7477,7 @@ namespace ts {
             // If object literal is contextually typed by the implied type of a binding pattern, augment the result
             // type with those properties for which the binding pattern specifies a default value.
             if (contextualTypeHasPattern) {
-                for (let prop of getPropertiesOfType(contextualType)) {
+                for (const prop of getPropertiesOfType(contextualType)) {
                     if (!hasProperty(propertiesTable, prop.name)) {
                         if (!(prop.flags & SymbolFlags.Optional)) {
                             error(prop.valueDeclaration || (<TransientSymbol>prop).bindingElement,
@@ -7473,10 +7489,10 @@ namespace ts {
                 }
             }
 
-            let stringIndexType = getIndexType(IndexKind.String);
-            let numberIndexType = getIndexType(IndexKind.Number);
-            let result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
-            let freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshObjectLiteral;
+            const stringIndexType = getIndexType(IndexKind.String);
+            const numberIndexType = getIndexType(IndexKind.Number);
+            const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
+            const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : TypeFlags.FreshObjectLiteral;
             result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | freshObjectLiteralFlag | (typeFlags & TypeFlags.PropagatingFlags);
             if (inDestructuringPattern) {
                 result.pattern = node;
@@ -7485,21 +7501,21 @@ namespace ts {
 
             function getIndexType(kind: IndexKind) {
                 if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) {
-                    let propTypes: Type[] = [];
+                    const propTypes: Type[] = [];
                     for (let i = 0; i < propertiesArray.length; i++) {
-                        let propertyDecl = node.properties[i];
+                        const propertyDecl = node.properties[i];
                         if (kind === IndexKind.String || isNumericName(propertyDecl.name)) {
                             // Do not call getSymbolOfNode(propertyDecl), as that will get the
                             // original symbol for the node. We actually want to get the symbol
                             // created by checkObjectLiteral, since that will be appropriately
                             // contextually typed and resolved.
-                            let type = getTypeOfSymbol(propertiesArray[i]);
+                            const type = getTypeOfSymbol(propertiesArray[i]);
                             if (!contains(propTypes, type)) {
                                 propTypes.push(type);
                             }
                         }
                     }
-                    let result = propTypes.length ? getUnionType(propTypes) : undefinedType;
+                    const result = propTypes.length ? getUnionType(propTypes) : undefinedType;
                     typeFlags |= result.flags;
                     return result;
                 }
@@ -7539,7 +7555,7 @@ namespace ts {
             }
 
             // Check children
-            for (let child of node.children) {
+            for (const child of node.children) {
                 switch (child.kind) {
                     case SyntaxKind.JsxExpression:
                         checkJsxExpression(<JsxExpression>child);
@@ -7585,11 +7601,11 @@ namespace ts {
                 error(node.parent, Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, getJsxElementPropertiesName());
             }
             else if (elementAttributesType && !isTypeAny(elementAttributesType)) {
-                let correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text);
+                const correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text);
                 correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol);
                 if (isUnhyphenatedJsxName(node.name.text)) {
                     // Maybe there's a string indexer?
-                    let indexerType = getIndexTypeOfType(elementAttributesType, IndexKind.String);
+                    const indexerType = getIndexTypeOfType(elementAttributesType, IndexKind.String);
                     if (indexerType) {
                         correspondingPropType = indexerType;
                     }
@@ -7621,15 +7637,15 @@ namespace ts {
         }
 
         function checkJsxSpreadAttribute(node: JsxSpreadAttribute, elementAttributesType: Type, nameTable: Map<boolean>) {
-            let type = checkExpression(node.expression);
-            let props = getPropertiesOfType(type);
-            for (let prop of props) {
+            const type = checkExpression(node.expression);
+            const props = getPropertiesOfType(type);
+            for (const prop of props) {
                 // Is there a corresponding property in the element attributes type? Skip checking of properties
                 // that have already been assigned to, as these are not actually pushed into the resulting type
                 if (!nameTable[prop.name]) {
-                    let targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
+                    const targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
                     if (targetPropSym) {
-                        let msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name);
+                        const msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name);
                         checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(targetPropSym), node, undefined, msg);
                     }
 
@@ -7654,8 +7670,8 @@ namespace ts {
         /// type or factory function.
         /// Otherwise, returns unknownSymbol.
         function getJsxElementTagSymbol(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
-            let flags: JsxFlags = JsxFlags.UnknownElement;
-            let links = getNodeLinks(node);
+            const flags: JsxFlags = JsxFlags.UnknownElement;
+            const links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
                 if (isJsxIntrinsicIdentifier(node.tagName)) {
                     links.resolvedSymbol = lookupIntrinsicTag(node);
@@ -7667,17 +7683,17 @@ namespace ts {
             return links.resolvedSymbol;
 
             function lookupIntrinsicTag(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
-                let intrinsicElementsType = getJsxIntrinsicElementsType();
+                const intrinsicElementsType = getJsxIntrinsicElementsType();
                 if (intrinsicElementsType !== unknownType) {
                     // Property case
-                    let intrinsicProp = getPropertyOfType(intrinsicElementsType, (<Identifier>node.tagName).text);
+                    const intrinsicProp = getPropertyOfType(intrinsicElementsType, (<Identifier>node.tagName).text);
                     if (intrinsicProp) {
                         links.jsxFlags |= JsxFlags.IntrinsicNamedElement;
                         return intrinsicProp;
                     }
 
                     // Intrinsic string indexer case
-                    let indexSignatureType = getIndexTypeOfType(intrinsicElementsType, IndexKind.String);
+                    const indexSignatureType = getIndexTypeOfType(intrinsicElementsType, IndexKind.String);
                     if (indexSignatureType) {
                         links.jsxFlags |= JsxFlags.IntrinsicIndexedElement;
                         return intrinsicElementsType.symbol;
@@ -7695,7 +7711,7 @@ namespace ts {
             }
 
             function lookupClassTag(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
-                let valueSymbol: Symbol = resolveJsxTagName(node);
+                const valueSymbol: Symbol = resolveJsxTagName(node);
 
                 // Look up the value in the current scope
                 if (valueSymbol && valueSymbol !== unknownSymbol) {
@@ -7710,8 +7726,8 @@ namespace ts {
 
             function resolveJsxTagName(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
                 if (node.tagName.kind === SyntaxKind.Identifier) {
-                    let tag = <Identifier>node.tagName;
-                    let sym = getResolvedSymbol(tag);
+                    const tag = <Identifier>node.tagName;
+                    const sym = getResolvedSymbol(tag);
                     return sym.exportSymbol || sym;
                 }
                 else {
@@ -7730,13 +7746,13 @@ namespace ts {
             // line shouldn't be hit.
             Debug.assert(!!(getNodeLinks(node).jsxFlags & JsxFlags.ClassElement), "Should not call getJsxElementInstanceType on non-class Element");
 
-            let classSymbol = getJsxElementTagSymbol(node);
+            const classSymbol = getJsxElementTagSymbol(node);
             if (classSymbol === unknownSymbol) {
                 // Couldn't find the class instance type. Error has already been issued
                 return anyType;
             }
 
-            let valueType = getTypeOfSymbol(classSymbol);
+            const valueType = getTypeOfSymbol(classSymbol);
             if (isTypeAny(valueType)) {
                 // Short-circuit if the class tag is using an element type 'any'
                 return anyType;
@@ -7755,10 +7771,10 @@ namespace ts {
                 }
             }
 
-            let returnType = getUnionType(signatures.map(getReturnTypeOfSignature));
+            const returnType = getUnionType(signatures.map(getReturnTypeOfSignature));
 
             // Issue an error if this return type isn't assignable to JSX.ElementClass
-            let elemClassType = getJsxGlobalElementClassType();
+            const elemClassType = getJsxGlobalElementClassType();
             if (elemClassType) {
                 checkTypeRelatedTo(returnType, elemClassType, assignableRelation, node, Diagnostics.JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements);
             }
@@ -7773,13 +7789,13 @@ namespace ts {
         ///     non-instrinsic elements' attributes type is the element instance type)
         function getJsxElementPropertiesName() {
             // JSX
-            let jsxNamespace = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/undefined);
+            const jsxNamespace = getGlobalSymbol(JsxNames.JSX, SymbolFlags.Namespace, /*diagnosticMessage*/undefined);
             // JSX.ElementAttributesProperty [symbol]
-            let attribsPropTypeSym = jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.ElementAttributesPropertyNameContainer, SymbolFlags.Type);
+            const attribsPropTypeSym = jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.ElementAttributesPropertyNameContainer, SymbolFlags.Type);
             // JSX.ElementAttributesProperty [type]
-            let attribPropType = attribsPropTypeSym && getDeclaredTypeOfSymbol(attribsPropTypeSym);
+            const attribPropType = attribsPropTypeSym && getDeclaredTypeOfSymbol(attribsPropTypeSym);
             // The properites of JSX.ElementAttributesProperty
-            let attribProperties = attribPropType && getPropertiesOfType(attribPropType);
+            const attribProperties = attribPropType && getPropertiesOfType(attribPropType);
 
             if (attribProperties) {
                 // Element Attributes has zero properties, so the element attributes type will be the class instance type
@@ -7808,18 +7824,18 @@ namespace ts {
          * us which attributes are valid on a given element.
          */
         function getJsxElementAttributesType(node: JsxOpeningLikeElement): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedJsxType) {
-                let sym = getJsxElementTagSymbol(node);
+                const sym = getJsxElementTagSymbol(node);
 
                 if (links.jsxFlags & JsxFlags.ClassElement) {
-                    let elemInstanceType = getJsxElementInstanceType(node);
+                    const elemInstanceType = getJsxElementInstanceType(node);
 
                     if (isTypeAny(elemInstanceType)) {
                         return links.resolvedJsxType = elemInstanceType;
                     }
 
-                    let propsName = getJsxElementPropertiesName();
+                    const propsName = getJsxElementPropertiesName();
                     if (propsName === undefined) {
                         // There is no type ElementAttributesProperty, return 'any'
                         return links.resolvedJsxType = anyType;
@@ -7829,7 +7845,7 @@ namespace ts {
                         return links.resolvedJsxType = elemInstanceType;
                     }
                     else {
-                        let attributesType = getTypeOfPropertyOfType(elemInstanceType, propsName);
+                        const attributesType = getTypeOfPropertyOfType(elemInstanceType, propsName);
 
                         if (!attributesType) {
                             // There is no property named 'props' on this instance type
@@ -7868,12 +7884,11 @@ namespace ts {
          * that have no matching element attributes type property.
          */
         function getJsxAttributePropertySymbol(attrib: JsxAttribute): Symbol {
-            let attributesType = getJsxElementAttributesType(<JsxOpeningElement>attrib.parent);
-            let prop = getPropertyOfType(attributesType, attrib.name.text);
+            const attributesType = getJsxElementAttributesType(<JsxOpeningElement>attrib.parent);
+            const prop = getPropertyOfType(attributesType, attrib.name.text);
             return prop || unknownSymbol;
         }
 
-        let jsxElementClassType: Type = undefined;
         function getJsxGlobalElementClassType(): Type {
             if (!jsxElementClassType) {
                 jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
@@ -7883,7 +7898,7 @@ namespace ts {
 
         /// Returns all the properties of the Jsx.IntrinsicElements interface
         function getJsxIntrinsicTagNames(): Symbol[] {
-            let intrinsics = getJsxIntrinsicElementsType();
+            const intrinsics = getJsxIntrinsicElementsType();
             return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
         }
 
@@ -7908,15 +7923,15 @@ namespace ts {
             // be marked as 'used' so we don't incorrectly elide its import. And if there
             // is no 'React' symbol in scope, we should issue an error.
             if (compilerOptions.jsx === JsxEmit.React) {
-                let reactSym = resolveName(node.tagName, "React", SymbolFlags.Value, Diagnostics.Cannot_find_name_0, "React");
+                const reactSym = resolveName(node.tagName, "React", SymbolFlags.Value, Diagnostics.Cannot_find_name_0, "React");
                 if (reactSym) {
                     getSymbolLinks(reactSym).referenced = true;
                 }
             }
 
-            let targetAttributesType = getJsxElementAttributesType(node);
+            const targetAttributesType = getJsxElementAttributesType(node);
 
-            let nameTable: Map<boolean> = {};
+            const nameTable: Map<boolean> = {};
             // Process this array in right-to-left order so we know which
             // attributes (mostly from spreads) are being overwritten and
             // thus should have their types ignored
@@ -7927,7 +7942,7 @@ namespace ts {
                 }
                 else {
                     Debug.assert(node.attributes[i].kind === SyntaxKind.JsxSpreadAttribute);
-                    let spreadType = checkJsxSpreadAttribute(<JsxSpreadAttribute>(node.attributes[i]), targetAttributesType, nameTable);
+                    const spreadType = checkJsxSpreadAttribute(<JsxSpreadAttribute>(node.attributes[i]), targetAttributesType, nameTable);
                     if (isTypeAny(spreadType)) {
                         sawSpreadedAny = true;
                     }
@@ -7937,7 +7952,7 @@ namespace ts {
             // Check that all required properties have been provided. If an 'any'
             // was spreaded in, though, assume that it provided all required properties
             if (targetAttributesType && !sawSpreadedAny) {
-                let targetProperties = getPropertiesOfType(targetAttributesType);
+                const targetProperties = getPropertiesOfType(targetAttributesType);
                 for (let i = 0; i < targetProperties.length; i++) {
                     if (!(targetProperties[i].flags & SymbolFlags.Optional) &&
                         nameTable[targetProperties[i].name] === undefined) {
@@ -7976,11 +7991,11 @@ namespace ts {
          * @param prop The symbol for the right hand side of the property access.
          */
         function checkClassPropertyAccess(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, type: Type, prop: Symbol): boolean {
-            let flags = getDeclarationFlagsFromSymbol(prop);
-            let declaringClass = <InterfaceType>getDeclaredTypeOfSymbol(prop.parent);
+            const flags = getDeclarationFlagsFromSymbol(prop);
+            const declaringClass = <InterfaceType>getDeclaredTypeOfSymbol(prop.parent);
 
             if (left.kind === SyntaxKind.SuperKeyword) {
-                let errorNode = node.kind === SyntaxKind.PropertyAccessExpression ?
+                const errorNode = node.kind === SyntaxKind.PropertyAccessExpression ?
                     (<PropertyAccessExpression>node).name :
                     (<QualifiedName>node).right;
 
@@ -8017,9 +8032,9 @@ namespace ts {
 
             // Property is known to be private or protected at this point
             // Get the declaring and enclosing class instance types
-            let enclosingClassDeclaration = getContainingClass(node);
+            const enclosingClassDeclaration = getContainingClass(node);
 
-            let enclosingClass = enclosingClassDeclaration ? <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
+            const enclosingClass = enclosingClassDeclaration ? <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClassDeclaration)) : undefined;
 
             // Private property is accessible if declaring and enclosing class are the same
             if (flags & NodeFlags.Private) {
@@ -8068,17 +8083,17 @@ namespace ts {
         }
 
         function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier) {
-            let type = checkExpression(left);
+            const type = checkExpression(left);
             if (isTypeAny(type)) {
                 return type;
             }
 
-            let apparentType = getApparentType(getWidenedType(type));
+            const apparentType = getApparentType(getWidenedType(type));
             if (apparentType === unknownType) {
                 // handle cases when type is Type parameter with invalid constraint
                 return unknownType;
             }
-            let prop = getPropertyOfType(apparentType, right.text);
+            const prop = getPropertyOfType(apparentType, right.text);
             if (!prop) {
                 if (right.text) {
                     error(right, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(right), typeToString(type.flags & TypeFlags.ThisType ? apparentType : type));
@@ -8095,13 +8110,13 @@ namespace ts {
         }
 
         function isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean {
-            let left = node.kind === SyntaxKind.PropertyAccessExpression
+            const left = node.kind === SyntaxKind.PropertyAccessExpression
                 ? (<PropertyAccessExpression>node).expression
                 : (<QualifiedName>node).left;
 
-            let type = checkExpression(left);
+            const type = checkExpression(left);
             if (type !== unknownType && !isTypeAny(type)) {
-                let prop = getPropertyOfType(getWidenedType(type), propertyName);
+                const prop = getPropertyOfType(getWidenedType(type), propertyName);
                 if (prop && prop.parent && prop.parent.flags & SymbolFlags.Class) {
                     return checkClassPropertyAccess(node, left, type, prop);
                 }
@@ -8112,28 +8127,28 @@ namespace ts {
         function checkIndexedAccess(node: ElementAccessExpression): Type {
             // Grammar checking
             if (!node.argumentExpression) {
-                let sourceFile = getSourceFile(node);
+                const sourceFile = getSourceFile(node);
                 if (node.parent.kind === SyntaxKind.NewExpression && (<NewExpression>node.parent).expression === node) {
-                    let start = skipTrivia(sourceFile.text, node.expression.end);
-                    let end = node.end;
+                    const start = skipTrivia(sourceFile.text, node.expression.end);
+                    const end = node.end;
                     grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead);
                 }
                 else {
-                    let start = node.end - "]".length;
-                    let end = node.end;
+                    const start = node.end - "]".length;
+                    const end = node.end;
                     grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Expression_expected);
                 }
             }
 
             // Obtain base constraint such that we can bail out if the constraint is an unknown type
-            let objectType = getApparentType(checkExpression(node.expression));
-            let indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType;
+            const objectType = getApparentType(checkExpression(node.expression));
+            const indexType = node.argumentExpression ? checkExpression(node.argumentExpression) : unknownType;
 
             if (objectType === unknownType) {
                 return unknownType;
             }
 
-            let isConstEnum = isConstEnumObjectType(objectType);
+            const isConstEnum = isConstEnumObjectType(objectType);
             if (isConstEnum &&
                 (!node.argumentExpression || node.argumentExpression.kind !== SyntaxKind.StringLiteral)) {
                 error(node.argumentExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
@@ -8151,9 +8166,9 @@ namespace ts {
 
             // See if we can index as a property.
             if (node.argumentExpression) {
-                let name = getPropertyNameForIndexedAccess(node.argumentExpression, indexType);
+                const name = getPropertyNameForIndexedAccess(node.argumentExpression, indexType);
                 if (name !== undefined) {
-                    let prop = getPropertyOfType(objectType, name);
+                    const prop = getPropertyOfType(objectType, name);
                     if (prop) {
                         getNodeLinks(node).resolvedSymbol = prop;
                         return getTypeOfSymbol(prop);
@@ -8170,14 +8185,14 @@ namespace ts {
 
                 // Try to use a number indexer.
                 if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, TypeFlags.NumberLike)) {
-                    let numberIndexType = getIndexTypeOfType(objectType, IndexKind.Number);
+                    const numberIndexType = getIndexTypeOfType(objectType, IndexKind.Number);
                     if (numberIndexType) {
                         return numberIndexType;
                     }
                 }
 
                 // Try to use string indexing.
-                let stringIndexType = getIndexTypeOfType(objectType, IndexKind.String);
+                const stringIndexType = getIndexTypeOfType(objectType, IndexKind.String);
                 if (stringIndexType) {
                     return stringIndexType;
                 }
@@ -8208,13 +8223,13 @@ namespace ts {
                 return (<LiteralExpression>indexArgumentExpression).text;
             }
             if (indexArgumentExpression.kind === SyntaxKind.ElementAccessExpression || indexArgumentExpression.kind === SyntaxKind.PropertyAccessExpression) {
-                let value = getConstantValue(<ElementAccessExpression | PropertyAccessExpression>indexArgumentExpression);
+                const value = getConstantValue(<ElementAccessExpression | PropertyAccessExpression>indexArgumentExpression);
                 if (value !== undefined) {
                     return value.toString();
                 }
             }
             if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, /*reportError*/ false)) {
-                let rightHandSideName = (<Identifier>(<PropertyAccessExpression>indexArgumentExpression).name).text;
+                const rightHandSideName = (<Identifier>(<PropertyAccessExpression>indexArgumentExpression).name).text;
                 return getPropertyNameForKnownSymbolName(rightHandSideName);
             }
 
@@ -8248,13 +8263,13 @@ namespace ts {
 
             // The name is Symbol.<someName>, so make sure Symbol actually resolves to the
             // global Symbol object
-            let leftHandSide = <Identifier>(<PropertyAccessExpression>expression).expression;
-            let leftHandSideSymbol = getResolvedSymbol(leftHandSide);
+            const leftHandSide = <Identifier>(<PropertyAccessExpression>expression).expression;
+            const leftHandSideSymbol = getResolvedSymbol(leftHandSide);
             if (!leftHandSideSymbol) {
                 return false;
             }
 
-            let globalESSymbol = getGlobalESSymbolConstructorSymbol();
+            const globalESSymbol = getGlobalESSymbolConstructorSymbol();
             if (!globalESSymbol) {
                 // Already errored when we tried to look up the symbol
                 return false;
@@ -8293,7 +8308,7 @@ namespace ts {
         // so order how inherited signatures are processed is still preserved.
         // interface A { (x: string): void }
         // interface B extends A { (x: 'foo'): string }
-        // let b: B;
+        // const b: B;
         // b('foo') // <- here overloads should be processed as [(x:'foo'): string, (x: string): void]
         function reorderCandidates(signatures: Signature[], result: Signature[]): void {
             let lastParent: Node;
@@ -8303,9 +8318,9 @@ namespace ts {
             let specializedIndex = -1;
             let spliceIndex: number;
             Debug.assert(!result.length);
-            for (let signature of signatures) {
-                let symbol = signature.declaration && getSymbolOfNode(signature.declaration);
-                let parent = signature.declaration && signature.declaration.parent;
+            for (const signature of signatures) {
+                const symbol = signature.declaration && getSymbolOfNode(signature.declaration);
+                const parent = signature.declaration && signature.declaration.parent;
                 if (!lastSymbol || symbol === lastSymbol) {
                     if (lastParent && parent === lastParent) {
                         index++;
@@ -8343,7 +8358,7 @@ namespace ts {
 
         function getSpreadArgumentIndex(args: Expression[]): number {
             for (let i = 0; i < args.length; i++) {
-                let arg = args[i];
+                const arg = args[i];
                 if (arg && arg.kind === SyntaxKind.SpreadElementExpression) {
                     return i;
                 }
@@ -8359,7 +8374,7 @@ namespace ts {
             let spreadArgIndex = -1;
 
             if (node.kind === SyntaxKind.TaggedTemplateExpression) {
-                let tagExpression = <TaggedTemplateExpression>node;
+                const tagExpression = <TaggedTemplateExpression>node;
 
                 // Even if the call is incomplete, we'll have a missing expression as our last argument,
                 // so we can say the count is just the arg list length
@@ -8369,8 +8384,8 @@ namespace ts {
                 if (tagExpression.template.kind === SyntaxKind.TemplateExpression) {
                     // If a tagged template expression lacks a tail literal, the call is incomplete.
                     // Specifically, a template only can end in a TemplateTail or a Missing literal.
-                    let templateExpression = <TemplateExpression>tagExpression.template;
-                    let lastSpan = lastOrUndefined(templateExpression.templateSpans);
+                    const templateExpression = <TemplateExpression>tagExpression.template;
+                    const lastSpan = lastOrUndefined(templateExpression.templateSpans);
                     Debug.assert(lastSpan !== undefined); // we should always have at least one span.
                     callIsIncomplete = nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
                 }
@@ -8378,7 +8393,7 @@ namespace ts {
                     // If the template didn't end in a backtick, or its beginning occurred right prior to EOF,
                     // then this might actually turn out to be a TemplateHead in the future;
                     // so we consider the call to be incomplete.
-                    let templateLiteral = <LiteralExpression>tagExpression.template;
+                    const templateLiteral = <LiteralExpression>tagExpression.template;
                     Debug.assert(templateLiteral.kind === SyntaxKind.NoSubstitutionTemplateLiteral);
                     callIsIncomplete = !!templateLiteral.isUnterminated;
                 }
@@ -8389,7 +8404,7 @@ namespace ts {
                 adjustedArgCount = getEffectiveArgumentCount(node, /*args*/ undefined, signature);
             }
             else {
-                let callExpression = <CallExpression>node;
+                const callExpression = <CallExpression>node;
                 if (!callExpression.arguments) {
                     // This only happens when we have something of the form: 'new C'
                     Debug.assert(callExpression.kind === SyntaxKind.NewExpression);
@@ -8409,7 +8424,7 @@ namespace ts {
 
             // If the user supplied type arguments, but the number of type arguments does not match
             // the declared number of type parameters, the call has an incorrect arity.
-            let hasRightNumberOfTypeArgs = !typeArguments ||
+            const hasRightNumberOfTypeArgs = !typeArguments ||
                 (signature.typeParameters && typeArguments.length === signature.typeParameters.length);
             if (!hasRightNumberOfTypeArgs) {
                 return false;
@@ -8427,14 +8442,14 @@ namespace ts {
             }
 
             // If the call is incomplete, we should skip the lower bound check.
-            let hasEnoughArguments = adjustedArgCount >= signature.minArgumentCount;
+            const hasEnoughArguments = adjustedArgCount >= signature.minArgumentCount;
             return callIsIncomplete || hasEnoughArguments;
         }
 
         // If type has a single call signature and no other members, return that signature. Otherwise, return undefined.
         function getSingleCallSignature(type: Type): Signature {
             if (type.flags & TypeFlags.ObjectType) {
-                let resolved = resolveStructuredTypeMembers(<ObjectType>type);
+                const resolved = resolveStructuredTypeMembers(<ObjectType>type);
                 if (resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0 &&
                     resolved.properties.length === 0 && !resolved.stringIndexType && !resolved.numberIndexType) {
                     return resolved.callSignatures[0];
@@ -8445,7 +8460,7 @@ namespace ts {
 
         // Instantiate a generic signature in the context of a non-generic signature (section 3.8.5 in TypeScript spec)
         function instantiateSignatureInContextOf(signature: Signature, contextualSignature: Signature, contextualMapper: TypeMapper): Signature {
-            let context = createInferenceContext(signature.typeParameters, /*inferUnionTypes*/ true);
+            const context = createInferenceContext(signature.typeParameters, /*inferUnionTypes*/ true);
             forEachMatchingParameterType(contextualSignature, signature, (source, target) => {
                 // Type parameters from outer context referenced by source type are fixed by instantiation of the source type
                 inferTypes(context, instantiateType(source, contextualMapper), target);
@@ -8454,8 +8469,8 @@ namespace ts {
         }
 
         function inferTypeArguments(node: CallLikeExpression, signature: Signature, args: Expression[], excludeArgument: boolean[], context: InferenceContext): void {
-            let typeParameters = signature.typeParameters;
-            let inferenceMapper = createInferenceMapper(context);
+            const typeParameters = signature.typeParameters;
+            const inferenceMapper = createInferenceMapper(context);
 
             // Clear out all the inference results from the last time inferTypeArguments was called on this context
             for (let i = 0; i < typeParameters.length; i++) {
@@ -8481,12 +8496,12 @@ namespace ts {
 
             // We perform two passes over the arguments. In the first pass we infer from all arguments, but use
             // wildcards for all context sensitive function expressions.
-            let argCount = getEffectiveArgumentCount(node, args, signature);
+            const argCount = getEffectiveArgumentCount(node, args, signature);
             for (let i = 0; i < argCount; i++) {
-                let arg = getEffectiveArgument(node, args, i);
+                const arg = getEffectiveArgument(node, args, i);
                 // If the effective argument is 'undefined', then it is an argument that is present but is synthetic.
                 if (arg === undefined || arg.kind !== SyntaxKind.OmittedExpression) {
-                    let paramType = getTypeAtPosition(signature, i);
+                    const paramType = getTypeAtPosition(signature, i);
                     let argType = getEffectiveArgumentType(node, i, arg);
 
                     // If the effective argument type is 'undefined', there is no synthetic type
@@ -8494,7 +8509,7 @@ namespace ts {
                     if (argType === undefined) {
                         // For context sensitive arguments we pass the identityMapper, which is a signal to treat all
                         // context sensitive function expressions as wildcards
-                        let mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper;
+                        const mapper = excludeArgument && excludeArgument[i] !== undefined ? identityMapper : inferenceMapper;
                         argType = checkExpressionWithContextualType(arg, paramType, mapper);
                     }
 
@@ -8511,8 +8526,8 @@ namespace ts {
                 for (let i = 0; i < argCount; i++) {
                     // No need to check for omitted args and template expressions, their exlusion value is always undefined
                     if (excludeArgument[i] === false) {
-                        let arg = args[i];
-                        let paramType = getTypeAtPosition(signature, i);
+                        const arg = args[i];
+                        const paramType = getTypeAtPosition(signature, i);
                         inferTypes(context, checkExpressionWithContextualType(arg, paramType, inferenceMapper), paramType);
                     }
                 }
@@ -8522,15 +8537,15 @@ namespace ts {
         }
 
         function checkTypeArguments(signature: Signature, typeArguments: TypeNode[], typeArgumentResultTypes: Type[], reportErrors: boolean, headMessage?: DiagnosticMessage): boolean {
-            let typeParameters = signature.typeParameters;
+            const typeParameters = signature.typeParameters;
             let typeArgumentsAreAssignable = true;
             for (let i = 0; i < typeParameters.length; i++) {
-                let typeArgNode = typeArguments[i];
-                let typeArgument = getTypeFromTypeNode(typeArgNode);
+                const typeArgNode = typeArguments[i];
+                const typeArgument = getTypeFromTypeNode(typeArgNode);
                 // Do not push on this array! It has a preallocated length
                 typeArgumentResultTypes[i] = typeArgument;
                 if (typeArgumentsAreAssignable /* so far */) {
-                    let constraint = getConstraintOfTypeParameter(typeParameters[i]);
+                    const constraint = getConstraintOfTypeParameter(typeParameters[i]);
                     if (constraint) {
                         let errorInfo: DiagnosticMessageChain;
                         let typeArgumentHeadMessage = Diagnostics.Type_0_does_not_satisfy_the_constraint_1;
@@ -8553,13 +8568,13 @@ namespace ts {
         }
 
         function checkApplicableSignature(node: CallLikeExpression, args: Expression[], signature: Signature, relation: Map<RelationComparisonResult>, excludeArgument: boolean[], reportErrors: boolean) {
-            let argCount = getEffectiveArgumentCount(node, args, signature);
+            const argCount = getEffectiveArgumentCount(node, args, signature);
             for (let i = 0; i < argCount; i++) {
-                let arg = getEffectiveArgument(node, args, i);
+                const arg = getEffectiveArgument(node, args, i);
                 // If the effective argument is 'undefined', then it is an argument that is present but is synthetic.
                 if (arg === undefined || arg.kind !== SyntaxKind.OmittedExpression) {
                     // Check spread elements against rest type (from arity check we know spread argument corresponds to a rest parameter)
-                    let paramType = getTypeAtPosition(signature, i);
+                    const paramType = getTypeAtPosition(signature, i);
                     let argType = getEffectiveArgumentType(node, i, arg);
 
                     // If the effective argument type is 'undefined', there is no synthetic type
@@ -8571,8 +8586,8 @@ namespace ts {
                     }
 
                     // Use argument expression as error location when reporting errors
-                    let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined;
-                    let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
+                    const errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined;
+                    const headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
                     if (!checkTypeRelatedTo(argType, paramType, relation, errorNode, headMessage)) {
                         return false;
                     }
@@ -8594,7 +8609,7 @@ namespace ts {
         function getEffectiveCallArguments(node: CallLikeExpression): Expression[] {
             let args: Expression[];
             if (node.kind === SyntaxKind.TaggedTemplateExpression) {
-                let template = (<TaggedTemplateExpression>node).template;
+                const template = (<TaggedTemplateExpression>node).template;
                 args = [undefined];
                 if (template.kind === SyntaxKind.TemplateExpression) {
                     forEach((<TemplateExpression>template).templateSpans, span => {
@@ -8686,7 +8701,7 @@ namespace ts {
             if (node.kind === SyntaxKind.ClassDeclaration) {
                 // For a class decorator, the `target` is the type of the class (e.g. the
                 // "static" or "constructor" side of the class)
-                let classSymbol = getSymbolOfNode(node);
+                const classSymbol = getSymbolOfNode(node);
                 return getTypeOfSymbol(classSymbol);
             }
 
@@ -8695,7 +8710,7 @@ namespace ts {
                 // parameter's containing method.
                 node = node.parent;
                 if (node.kind === SyntaxKind.Constructor) {
-                    let classSymbol = getSymbolOfNode(node);
+                    const classSymbol = getSymbolOfNode(node);
                     return getTypeOfSymbol(classSymbol);
                 }
             }
@@ -8756,7 +8771,7 @@ namespace ts {
                 // string literal type if the member name is an identifier, number, or string;
                 // otherwise, if the member name is a computed property name it will
                 // be either string or symbol.
-                let element = <ClassElement>node;
+                const element = <ClassElement>node;
                 switch (element.name.kind) {
                     case SyntaxKind.Identifier:
                     case SyntaxKind.NumericLiteral:
@@ -8764,7 +8779,7 @@ namespace ts {
                         return getStringLiteralType(<StringLiteral>element.name);
 
                     case SyntaxKind.ComputedPropertyName:
-                        let nameType = checkComputedPropertyName(<ComputedPropertyName>element.name);
+                        const nameType = checkComputedPropertyName(<ComputedPropertyName>element.name);
                         if (allConstituentTypesHaveKind(nameType, TypeFlags.ESSymbol)) {
                             return nameType;
                         }
@@ -8812,7 +8827,7 @@ namespace ts {
                 node.kind === SyntaxKind.SetAccessor) {
                 // The `descriptor` for a method decorator will be a `TypedPropertyDescriptor<T>`
                 // for the type of the member.
-                let propertyType = getTypeOfNode(node);
+                const propertyType = getTypeOfNode(node);
                 return createTypedPropertyDescriptorType(propertyType);
             }
 
@@ -8888,8 +8903,8 @@ namespace ts {
         }
 
         function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[], headMessage?: DiagnosticMessage): Signature {
-            let isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
-            let isDecorator = node.kind === SyntaxKind.Decorator;
+            const isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
+            const isDecorator = node.kind === SyntaxKind.Decorator;
 
             let typeArguments: TypeNode[];
 
@@ -8902,7 +8917,7 @@ namespace ts {
                 }
             }
 
-            let candidates = candidatesOutArray || [];
+            const candidates = candidatesOutArray || [];
             // reorderCandidates fills up the candidates array directly
             reorderCandidates(signatures, candidates);
             if (!candidates.length) {
@@ -8910,7 +8925,7 @@ namespace ts {
                 return resolveErrorCall(node);
             }
 
-            let args = getEffectiveCallArguments(node);
+            const args = getEffectiveCallArguments(node);
 
             // The following applies to any value of 'excludeArgument[i]':
             //    - true:      the argument at 'i' is susceptible to a one-time permanent contextual typing.
@@ -9008,8 +9023,8 @@ namespace ts {
                 }
                 else {
                     Debug.assert(resultOfFailedInference.failedTypeParameterIndex >= 0);
-                    let failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex];
-                    let inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex);
+                    const failedTypeParameter = candidateForTypeArgumentError.typeParameters[resultOfFailedInference.failedTypeParameterIndex];
+                    const inferenceCandidates = getInferenceCandidates(resultOfFailedInference, resultOfFailedInference.failedTypeParameterIndex);
 
                     let diagnosticChainHead = chainDiagnosticMessages(/*details*/ undefined, // details will be provided by call to reportNoCommonSupertypeError
                         Diagnostics.The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly,
@@ -9055,14 +9070,14 @@ namespace ts {
             }
 
             function chooseOverload(candidates: Signature[], relation: Map<RelationComparisonResult>) {
-                for (let originalCandidate of candidates) {
+                for (const originalCandidate of candidates) {
                     if (!hasCorrectArity(node, args, originalCandidate)) {
                         continue;
                     }
 
                     let candidate: Signature;
                     let typeArgumentsAreValid: boolean;
-                    let inferenceContext = originalCandidate.typeParameters
+                    const inferenceContext = originalCandidate.typeParameters
                         ? createInferenceContext(originalCandidate.typeParameters, /*inferUnionTypes*/ false)
                         : undefined;
 
@@ -9087,7 +9102,7 @@ namespace ts {
                         if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
                             break;
                         }
-                        let index = excludeArgument ? indexOf(excludeArgument, true) : -1;
+                        const index = excludeArgument ? indexOf(excludeArgument, true) : -1;
                         if (index < 0) {
                             return candidate;
                         }
@@ -9100,7 +9115,7 @@ namespace ts {
                     // report an error based on the arguments. If there was an issue with type
                     // arguments, then we can only report an error based on the type arguments.
                     if (originalCandidate.typeParameters) {
-                        let instantiatedCandidate = candidate;
+                        const instantiatedCandidate = candidate;
                         if (typeArgumentsAreValid) {
                             candidateForArgumentError = instantiatedCandidate;
                         }
@@ -9124,19 +9139,19 @@ namespace ts {
 
         function resolveCallExpression(node: CallExpression, candidatesOutArray: Signature[]): Signature {
             if (node.expression.kind === SyntaxKind.SuperKeyword) {
-                let superType = checkSuperExpression(node.expression);
+                const superType = checkSuperExpression(node.expression);
                 if (superType !== unknownType) {
                     // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated
                     // with the type arguments specified in the extends clause.
-                    let baseTypeNode = getClassExtendsHeritageClauseElement(getContainingClass(node));
-                    let baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments);
+                    const baseTypeNode = getClassExtendsHeritageClauseElement(getContainingClass(node));
+                    const baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments);
                     return resolveCall(node, baseConstructors, candidatesOutArray);
                 }
                 return resolveUntypedCall(node);
             }
 
-            let funcType = checkExpression(node.expression);
-            let apparentType = getApparentType(funcType);
+            const funcType = checkExpression(node.expression);
+            const apparentType = getApparentType(funcType);
 
             if (apparentType === unknownType) {
                 // Another error has already been reported
@@ -9147,9 +9162,9 @@ namespace ts {
             // but we are not including call signatures that may have been added to the Object or
             // Function interface, since they have none by default. This is a bit of a leap of faith
             // that the user will not add any.
-            let callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
+            const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
 
-            let constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
+            const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
             // TS 1.0 spec: 4.12
             // If FuncExpr is of type Any, or of an object type that has no call or construct signatures
             // but is a subtype of the Function interface, the call is an untyped function call. In an
@@ -9182,7 +9197,7 @@ namespace ts {
 
         function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
             if (node.arguments && languageVersion < ScriptTarget.ES5) {
-                let spreadIndex = getSpreadArgumentIndex(node.arguments);
+                const spreadIndex = getSpreadArgumentIndex(node.arguments);
                 if (spreadIndex >= 0) {
                     error(node.arguments[spreadIndex], Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
                 }
@@ -9205,7 +9220,7 @@ namespace ts {
             // Note, only class declarations can be declared abstract.
             // In the case of a merged class-module or class-interface declaration,
             // only the class declaration node will have the Abstract flag set.
-            let valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
+            const valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
             if (valueDecl && valueDecl.flags & NodeFlags.Abstract) {
                 error(node, Diagnostics.Cannot_create_an_instance_of_the_abstract_class_0, declarationNameToString(valueDecl.name));
                 return resolveErrorCall(node);
@@ -9225,7 +9240,7 @@ namespace ts {
             // but we are not including construct signatures that may have been added to the Object or
             // Function interface, since they have none by default. This is a bit of a leap of faith
             // that the user will not add any.
-            let constructSignatures = getSignaturesOfType(expressionType, SignatureKind.Construct);
+            const constructSignatures = getSignaturesOfType(expressionType, SignatureKind.Construct);
             if (constructSignatures.length) {
                 return resolveCall(node, constructSignatures, candidatesOutArray);
             }
@@ -9234,9 +9249,9 @@ namespace ts {
             // one or more call signatures, the expression is processed as a function call. A compile-time
             // error occurs if the result of the function call is not Void. The type of the result of the
             // operation is Any.
-            let callSignatures = getSignaturesOfType(expressionType, SignatureKind.Call);
+            const callSignatures = getSignaturesOfType(expressionType, SignatureKind.Call);
             if (callSignatures.length) {
-                let signature = resolveCall(node, callSignatures, candidatesOutArray);
+                const signature = resolveCall(node, callSignatures, candidatesOutArray);
                 if (getReturnTypeOfSignature(signature) !== voidType) {
                     error(node, Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);
                 }
@@ -9248,15 +9263,15 @@ namespace ts {
         }
 
         function resolveTaggedTemplateExpression(node: TaggedTemplateExpression, candidatesOutArray: Signature[]): Signature {
-            let tagType = checkExpression(node.tag);
-            let apparentType = getApparentType(tagType);
+            const tagType = checkExpression(node.tag);
+            const apparentType = getApparentType(tagType);
 
             if (apparentType === unknownType) {
                 // Another error has already been reported
                 return resolveErrorCall(node);
             }
 
-            let callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
+            const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
 
             if (isTypeAny(tagType) || (!callSignatures.length && !(tagType.flags & TypeFlags.Union) && isTypeAssignableTo(tagType, globalFunctionType))) {
                 return resolveUntypedCall(node);
@@ -9296,18 +9311,18 @@ namespace ts {
           * Resolves a decorator as if it were a call expression.
           */
         function resolveDecorator(node: Decorator, candidatesOutArray: Signature[]): Signature {
-            let funcType = checkExpression(node.expression);
-            let apparentType = getApparentType(funcType);
+            const funcType = checkExpression(node.expression);
+            const apparentType = getApparentType(funcType);
             if (apparentType === unknownType) {
                 return resolveErrorCall(node);
             }
 
-            let callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
+            const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
             if (funcType === anyType || (!callSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
                 return resolveUntypedCall(node);
             }
 
-            let headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
+            const headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
             if (!callSignatures.length) {
                 let errorInfo: DiagnosticMessageChain;
                 errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Cannot_invoke_an_expression_whose_type_lacks_a_call_signature);
@@ -9322,7 +9337,7 @@ namespace ts {
         // candidatesOutArray is passed by signature help in the language service, and collectCandidates
         // must fill it up with the appropriate candidate signatures
         function getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             // If getResolvedSignature has already been called, we will have cached the resolvedSignature.
             // However, it is possible that either candidatesOutArray was not passed in the first time,
             // or that a different candidatesOutArray was passed in. Therefore, we need to redo the work
@@ -9358,12 +9373,12 @@ namespace ts {
             // Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true
             checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);
 
-            let signature = getResolvedSignature(node);
+            const signature = getResolvedSignature(node);
             if (node.expression.kind === SyntaxKind.SuperKeyword) {
                 return voidType;
             }
             if (node.kind === SyntaxKind.NewExpression) {
-                let declaration = signature.declaration;
+                const declaration = signature.declaration;
 
                 if (declaration &&
                     declaration.kind !== SyntaxKind.Constructor &&
@@ -9385,10 +9400,10 @@ namespace ts {
         }
 
         function checkAssertion(node: AssertionExpression) {
-            let exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
-            let targetType = getTypeFromTypeNode(node.type);
+            const exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
+            const targetType = getTypeFromTypeNode(node.type);
             if (produceDiagnostics && targetType !== unknownType) {
-                let widenedType = getWidenedType(exprType);
+                const widenedType = getWidenedType(exprType);
                 if (!(isTypeAssignableTo(targetType, widenedType))) {
                     checkTypeAssignableTo(exprType, targetType, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other);
                 }
@@ -9403,15 +9418,15 @@ namespace ts {
         }
 
         function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) {
-            let len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
             for (let i = 0; i < len; i++) {
-                let parameter = signature.parameters[i];
-                let contextualParameterType = getTypeAtPosition(context, i);
+                const parameter = signature.parameters[i];
+                const contextualParameterType = getTypeAtPosition(context, i);
                 assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
             }
             if (signature.hasRestParameter && isRestParameterIndex(context, signature.parameters.length - 1)) {
-                let parameter = lastOrUndefined(signature.parameters);
-                let contextualParameterType = getTypeOfSymbol(lastOrUndefined(context.parameters));
+                const parameter = lastOrUndefined(signature.parameters);
+                const contextualParameterType = getTypeOfSymbol(lastOrUndefined(context.parameters));
                 assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
             }
         }
@@ -9420,7 +9435,7 @@ namespace ts {
         // the destructured type into the contained binding elements.
         function assignBindingElementTypes(node: VariableLikeDeclaration) {
             if (isBindingPattern(node.name)) {
-                for (let element of (<BindingPattern>node.name).elements) {
+                for (const element of (<BindingPattern>node.name).elements) {
                     if (element.kind !== SyntaxKind.OmittedExpression) {
                         if (element.name.kind === SyntaxKind.Identifier) {
                             getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
@@ -9432,7 +9447,7 @@ namespace ts {
         }
 
         function assignTypeToParameterAndFixTypeParameters(parameter: Symbol, contextualType: Type, mapper: TypeMapper) {
-            let links = getSymbolLinks(parameter);
+            const links = getSymbolLinks(parameter);
             if (!links.type) {
                 links.type = instantiateType(contextualType, mapper);
                 assignBindingElementTypes(<ParameterDeclaration>parameter.valueDeclaration);
@@ -9473,7 +9488,7 @@ namespace ts {
 
         function createPromiseType(promisedType: Type): Type {
             // creates a `Promise<T>` type where `T` is the promisedType argument
-            let globalPromiseType = getGlobalPromiseType();
+            const globalPromiseType = getGlobalPromiseType();
             if (globalPromiseType !== emptyGenericType) {
                 // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type
                 promisedType = getAwaitedType(promisedType);
@@ -9484,12 +9499,12 @@ namespace ts {
         }
 
         function getReturnTypeFromBody(func: FunctionLikeDeclaration, contextualMapper?: TypeMapper): Type {
-            let contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
+            const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
             if (!func.body) {
                 return unknownType;
             }
 
-            let isAsync = isAsyncFunctionLike(func);
+            const isAsync = isAsyncFunctionLike(func);
             let type: Type;
             if (func.body.kind !== SyntaxKind.Block) {
                 type = checkExpressionCached(<Expression>func.body, contextualMapper);
@@ -9503,11 +9518,11 @@ namespace ts {
             }
             else {
                 let types: Type[];
-                let funcIsGenerator = !!func.asteriskToken;
+                const funcIsGenerator = !!func.asteriskToken;
                 if (funcIsGenerator) {
                     types = checkAndAggregateYieldOperandTypes(<Block>func.body, contextualMapper);
                     if (types.length === 0) {
-                        let iterableIteratorAny = createIterableIteratorType(anyType);
+                        const iterableIteratorAny = createIterableIteratorType(anyType);
                         if (compilerOptions.noImplicitAny) {
                             error(func.asteriskToken,
                                 Diagnostics.Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type, typeToString(iterableIteratorAny));
@@ -9520,7 +9535,7 @@ namespace ts {
                     if (types.length === 0) {
                         if (isAsync) {
                             // For an async function, the return type will not be void, but rather a Promise for void.
-                            let promiseType = createPromiseType(voidType);
+                            const promiseType = createPromiseType(voidType);
                             if (promiseType === emptyObjectType) {
                                 error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type);
                                 return unknownType;
@@ -9555,12 +9570,12 @@ namespace ts {
                 reportErrorsFromWidening(func, type);
             }
 
-            let widenedType = getWidenedType(type);
+            const widenedType = getWidenedType(type);
             if (isAsync) {
                 // From within an async function you can return either a non-promise value or a promise. Any
                 // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
                 // return type of the body is awaited type of the body, wrapped in a native Promise<T> type.
-                let promiseType = createPromiseType(widenedType);
+                const promiseType = createPromiseType(widenedType);
                 if (promiseType === emptyObjectType) {
                     error(func, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type);
                     return unknownType;
@@ -9574,10 +9589,10 @@ namespace ts {
         }
 
         function checkAndAggregateYieldOperandTypes(body: Block, contextualMapper?: TypeMapper): Type[] {
-            let aggregatedTypes: Type[] = [];
+            const aggregatedTypes: Type[] = [];
 
             forEachYieldExpression(body, yieldExpression => {
-                let expr = yieldExpression.expression;
+                const expr = yieldExpression.expression;
                 if (expr) {
                     let type = checkExpressionCached(expr, contextualMapper);
 
@@ -9596,10 +9611,10 @@ namespace ts {
         }
 
         function checkAndAggregateReturnExpressionTypes(body: Block, contextualMapper?: TypeMapper, isAsync?: boolean): Type[] {
-            let aggregatedTypes: Type[] = [];
+            const aggregatedTypes: Type[] = [];
 
             forEachReturnStatement(body, returnStatement => {
-                let expr = returnStatement.expression;
+                const expr = returnStatement.expression;
                 if (expr) {
                     let type = checkExpressionCached(expr, contextualMapper);
                     if (isAsync) {
@@ -9619,21 +9634,11 @@ namespace ts {
             return aggregatedTypes;
         }
 
-        function bodyContainsAReturnStatement(funcBody: Block) {
-            return forEachReturnStatement(funcBody, returnStatement => {
-                return true;
-            });
-        }
-
-        function bodyContainsSingleThrowStatement(body: Block) {
-            return (body.statements.length === 1) && (body.statements[0].kind === SyntaxKind.ThrowStatement);
-        }
-
         // TypeScript Specification 1.0 (6.3) - July 2014
         // An explicitly typed function whose return type isn't the Void or the Any type
         // must have at least one return statement somewhere in its body.
         // An exception to this rule is if the function implementation consists of a single 'throw' statement.
-        function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func: FunctionLikeDeclaration, returnType: Type): void {
+        function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func: FunctionLikeDeclaration, returnType: Type): void {
             if (!produceDiagnostics) {
                 return;
             }
@@ -9644,33 +9649,27 @@ namespace ts {
             }
 
             // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check.
-            if (nodeIsMissing(func.body) || func.body.kind !== SyntaxKind.Block) {
+            // also if HasImplicitReturnValue flags is not set this means that all codepaths in function body end with return of throw
+            if (nodeIsMissing(func.body) || func.body.kind !== SyntaxKind.Block || !(func.flags & NodeFlags.HasImplicitReturn)) {
                 return;
             }
 
-            let bodyBlock = <Block>func.body;
-
-            // Ensure the body has at least one return expression.
-            if (bodyContainsAReturnStatement(bodyBlock)) {
-                return;
+            if (func.flags & NodeFlags.HasExplicitReturn) {
+                if (compilerOptions.noImplicitReturns) {
+                    error(func.type, Diagnostics.Not_all_code_paths_return_a_value);
+                }
             }
-
-            // If there are no return expressions, then we need to check if
-            // the function body consists solely of a throw statement;
-            // this is to make an exception for unimplemented functions.
-            if (bodyContainsSingleThrowStatement(bodyBlock)) {
-                return;
+            else {
+                // This function does not conform to the specification.
+                error(func.type, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
             }
-
-            // This function does not conform to the specification.
-            error(func.type, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement);
         }
 
         function checkFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | MethodDeclaration, contextualMapper?: TypeMapper): Type {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
 
             // Grammar checking
-            let hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
+            const hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
             if (!hasGrammarError && node.kind === SyntaxKind.FunctionExpression) {
                 checkGrammarForGenerator(node);
             }
@@ -9680,34 +9679,34 @@ namespace ts {
                 return anyFunctionType;
             }
 
-            let isAsync = isAsyncFunctionLike(node);
+            const isAsync = isAsyncFunctionLike(node);
             if (isAsync) {
                 emitAwaiter = true;
             }
 
-            let links = getNodeLinks(node);
-            let type = getTypeOfSymbol(node.symbol);
-            let contextSensitive = isContextSensitive(node);
-            let mightFixTypeParameters = contextSensitive && isInferentialContext(contextualMapper);
+            const links = getNodeLinks(node);
+            const type = getTypeOfSymbol(node.symbol);
+            const contextSensitive = isContextSensitive(node);
+            const mightFixTypeParameters = contextSensitive && isInferentialContext(contextualMapper);
 
             // Check if function expression is contextually typed and assign parameter types if so.
             // See the comment in assignTypeToParameterAndFixTypeParameters to understand why we need to
             // check mightFixTypeParameters.
             if (mightFixTypeParameters || !(links.flags & NodeCheckFlags.ContextChecked)) {
-                let contextualSignature = getContextualSignature(node);
+                const contextualSignature = getContextualSignature(node);
                 // If a type check is started at a function expression that is an argument of a function call, obtaining the
                 // contextual type may recursively get back to here during overload resolution of the call. If so, we will have
                 // already assigned contextual types.
-                let contextChecked = !!(links.flags & NodeCheckFlags.ContextChecked);
+                const contextChecked = !!(links.flags & NodeCheckFlags.ContextChecked);
                 if (mightFixTypeParameters || !contextChecked) {
                     links.flags |= NodeCheckFlags.ContextChecked;
                     if (contextualSignature) {
-                        let signature = getSignaturesOfType(type, SignatureKind.Call)[0];
+                        const signature = getSignaturesOfType(type, SignatureKind.Call)[0];
                         if (contextSensitive) {
                             assignContextualParameterTypes(signature, contextualSignature, contextualMapper || identityMapper);
                         }
                         if (mightFixTypeParameters || !node.type && !signature.resolvedReturnType) {
-                            let returnType = getReturnTypeFromBody(node, contextualMapper);
+                            const returnType = getReturnTypeFromBody(node, contextualMapper);
                             if (!signature.resolvedReturnType) {
                                 signature.resolvedReturnType = returnType;
                             }
@@ -9731,19 +9730,19 @@ namespace ts {
         function checkFunctionExpressionOrObjectLiteralMethodBody(node: FunctionExpression | MethodDeclaration) {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
 
-            let isAsync = isAsyncFunctionLike(node);
+            const isAsync = isAsyncFunctionLike(node);
             if (isAsync) {
                 emitAwaiter = true;
             }
 
-            let returnType = node.type && getTypeFromTypeNode(node.type);
+            const returnType = node.type && getTypeFromTypeNode(node.type);
             let promisedType: Type;
             if (returnType && isAsync) {
                 promisedType = checkAsyncFunctionReturnType(node);
             }
 
             if (returnType && !node.asteriskToken) {
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
 
             if (node.body) {
@@ -9765,10 +9764,10 @@ namespace ts {
                     // should not be checking assignability of a promise to the return type. Instead, we need to
                     // check assignability of the awaited type of the expression body against the promised type of
                     // its return type annotation.
-                    let exprType = checkExpression(<Expression>node.body);
+                    const exprType = checkExpression(<Expression>node.body);
                     if (returnType) {
                         if (isAsync) {
-                            let awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member);
+                            const awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member);
                             checkTypeAssignableTo(awaitedType, promisedType, node.body);
                         }
                         else {
@@ -9791,7 +9790,7 @@ namespace ts {
 
         function checkReferenceExpression(n: Node, invalidReferenceMessage: DiagnosticMessage, constantVariableMessage: DiagnosticMessage): boolean {
             function findSymbol(n: Node): Symbol {
-                let symbol = getNodeLinks(n).resolvedSymbol;
+                const symbol = getNodeLinks(n).resolvedSymbol;
                 // Because we got the symbol from the resolvedSymbol property, it might be of kind
                 // SymbolFlags.ExportValue. In this case it is necessary to get the actual export
                 // symbol, which will have the correct flags set on it.
@@ -9807,14 +9806,14 @@ namespace ts {
                 // All other expression constructs described in this chapter are classified as values.
                 switch (n.kind) {
                     case SyntaxKind.Identifier: {
-                        let symbol = findSymbol(n);
+                        const symbol = findSymbol(n);
                         // TypeScript 1.0 spec (April 2014): 4.3
                         // An identifier expression that references a variable or parameter is classified as a reference.
                         // An identifier expression that references any other kind of entity is classified as a value(and therefore cannot be the target of an assignment).
                         return !symbol || symbol === unknownSymbol || symbol === argumentsSymbol || (symbol.flags & SymbolFlags.Variable) !== 0;
                     }
                     case SyntaxKind.PropertyAccessExpression: {
-                        let symbol = findSymbol(n);
+                        const symbol = findSymbol(n);
                         // TypeScript 1.0 spec (April 2014): 4.10
                         // A property access expression is always classified as a reference.
                         // NOTE (not in spec): assignment to enum members should not be allowed
@@ -9834,15 +9833,15 @@ namespace ts {
                 switch (n.kind) {
                     case SyntaxKind.Identifier:
                     case SyntaxKind.PropertyAccessExpression: {
-                        let symbol = findSymbol(n);
+                        const symbol = findSymbol(n);
                         return symbol && (symbol.flags & SymbolFlags.Variable) !== 0 && (getDeclarationFlagsFromSymbol(symbol) & NodeFlags.Const) !== 0;
                     }
                     case SyntaxKind.ElementAccessExpression: {
-                        let index = (<ElementAccessExpression>n).argumentExpression;
-                        let symbol = findSymbol((<ElementAccessExpression>n).expression);
+                        const index = (<ElementAccessExpression>n).argumentExpression;
+                        const symbol = findSymbol((<ElementAccessExpression>n).expression);
                         if (symbol && index && index.kind === SyntaxKind.StringLiteral) {
-                            let name = (<LiteralExpression>index).text;
-                            let prop = getPropertyOfType(getTypeOfSymbol(symbol), name);
+                            const name = (<LiteralExpression>index).text;
+                            const prop = getPropertyOfType(getTypeOfSymbol(symbol), name);
                             return prop && (prop.flags & SymbolFlags.Variable) !== 0 && (getDeclarationFlagsFromSymbol(prop) & NodeFlags.Const) !== 0;
                         }
                         return false;
@@ -9894,12 +9893,12 @@ namespace ts {
                 }
             }
 
-            let operandType = checkExpression(node.expression);
+            const operandType = checkExpression(node.expression);
             return checkAwaitedType(operandType, node);
         }
 
         function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type {
-            let operandType = checkExpression(node.operand);
+            const operandType = checkExpression(node.operand);
             switch (node.operator) {
                 case SyntaxKind.PlusToken:
                 case SyntaxKind.MinusToken:
@@ -9912,7 +9911,7 @@ namespace ts {
                     return booleanType;
                 case SyntaxKind.PlusPlusToken:
                 case SyntaxKind.MinusMinusToken:
-                    let ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
+                    const ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
                     if (ok) {
                         // run check only if former checks succeeded to avoid reporting cascading errors
                         checkReferenceExpression(node.operand,
@@ -9925,8 +9924,8 @@ namespace ts {
         }
 
         function checkPostfixUnaryExpression(node: PostfixUnaryExpression): Type {
-            let operandType = checkExpression(node.operand);
-            let ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
+            const operandType = checkExpression(node.operand);
+            const ok = checkArithmeticOperandType(node.operand, operandType, Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
             if (ok) {
                 // run check only if former checks succeeded to avoid reporting cascading errors
                 checkReferenceExpression(node.operand,
@@ -9943,8 +9942,8 @@ namespace ts {
                 return true;
             }
             if (type.flags & TypeFlags.UnionOrIntersection) {
-                let types = (<UnionOrIntersectionType>type).types;
-                for (let current of types) {
+                const types = (<UnionOrIntersectionType>type).types;
+                for (const current of types) {
                     if (current.flags & kind) {
                         return true;
                     }
@@ -9960,8 +9959,8 @@ namespace ts {
                 return true;
             }
             if (type.flags & TypeFlags.UnionOrIntersection) {
-                let types = (<UnionOrIntersectionType>type).types;
-                for (let current of types) {
+                const types = (<UnionOrIntersectionType>type).types;
+                for (const current of types) {
                     if (!(current.flags & kind)) {
                         return false;
                     }
@@ -10010,12 +10009,12 @@ namespace ts {
         }
 
         function checkObjectLiteralAssignment(node: ObjectLiteralExpression, sourceType: Type, contextualMapper?: TypeMapper): Type {
-            let properties = node.properties;
-            for (let p of properties) {
+            const properties = node.properties;
+            for (const p of properties) {
                 if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
                     // TODO(andersh): Computed property support
-                    let name = <Identifier>(<PropertyAssignment>p).name;
-                    let type = isTypeAny(sourceType)
+                    const name = <Identifier>(<PropertyAssignment>p).name;
+                    const type = isTypeAny(sourceType)
                         ? sourceType
                         : getTypeOfPropertyOfType(sourceType, name.text) ||
                         isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) ||
@@ -10043,14 +10042,14 @@ namespace ts {
             // This elementType will be used if the specific property corresponding to this index is not
             // present (aka the tuple element property). This call also checks that the parentType is in
             // fact an iterable or array (depending on target language).
-            let elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false) || unknownType;
-            let elements = node.elements;
+            const elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false) || unknownType;
+            const elements = node.elements;
             for (let i = 0; i < elements.length; i++) {
-                let e = elements[i];
+                const e = elements[i];
                 if (e.kind !== SyntaxKind.OmittedExpression) {
                     if (e.kind !== SyntaxKind.SpreadElementExpression) {
-                        let propName = "" + i;
-                        let type = isTypeAny(sourceType)
+                        const propName = "" + i;
+                        const type = isTypeAny(sourceType)
                             ? sourceType
                             : isTupleLikeType(sourceType)
                                 ? getTypeOfPropertyOfType(sourceType, propName)
@@ -10072,7 +10071,7 @@ namespace ts {
                             error(e, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                         }
                         else {
-                            let restExpression = (<SpreadElementExpression>e).expression;
+                            const restExpression = (<SpreadElementExpression>e).expression;
                             if (restExpression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>restExpression).operatorToken.kind === SyntaxKind.EqualsToken) {
                                 error((<BinaryExpression>restExpression).operatorToken, Diagnostics.A_rest_element_cannot_have_an_initializer);
                             }
@@ -10113,7 +10112,7 @@ namespace ts {
         }
 
         function checkReferenceAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type {
-            let targetType = checkExpression(target, contextualMapper);
+            const targetType = checkExpression(target, contextualMapper);
             if (checkReferenceExpression(target, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant)) {
                 checkTypeAssignableTo(sourceType, targetType, target, /*headMessage*/ undefined);
             }
@@ -10125,7 +10124,7 @@ namespace ts {
         }
 
         function checkBinaryLikeExpression(left: Expression, operatorToken: Node, right: Expression, contextualMapper?: TypeMapper, errorNode?: Node) {
-            let operator = operatorToken.kind;
+            const operator = operatorToken.kind;
             if (operator === SyntaxKind.EqualsToken && (left.kind === SyntaxKind.ObjectLiteralExpression || left.kind === SyntaxKind.ArrayLiteralExpression)) {
                 return checkDestructuringAssignment(left, checkExpression(right, contextualMapper), contextualMapper);
             }
@@ -10173,8 +10172,8 @@ namespace ts {
                     }
                     else {
                         // otherwise just check each operand separately and report errors as normal
-                        let leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
-                        let rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
+                        const leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
+                        const rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type);
                         if (leftOk && rightOk) {
                             checkAssignmentOperator(numberType);
                         }
@@ -10256,7 +10255,7 @@ namespace ts {
 
             // Return true if there was no error, false if there was an error.
             function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean {
-                let offendingSymbolOperand =
+                const offendingSymbolOperand =
                     someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? left :
                         someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? right :
                             undefined;
@@ -10292,7 +10291,7 @@ namespace ts {
                     // requires VarExpr to be classified as a reference
                     // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1)
                     // and the type of the non - compound operation to be assignable to the type of VarExpr.
-                    let ok = checkReferenceExpression(left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
+                    const ok = checkReferenceExpression(left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant);
                     // Use default messages
                     if (ok) {
                         // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported
@@ -10337,13 +10336,13 @@ namespace ts {
             }
 
             if (node.expression) {
-                let func = getContainingFunction(node);
+                const func = getContainingFunction(node);
                 // If the user's code is syntactically correct, the func should always have a star. After all,
                 // we are in a yield context.
                 if (func && func.asteriskToken) {
-                    let expressionType = checkExpressionCached(node.expression, /*contextualMapper*/ undefined);
+                    const expressionType = checkExpressionCached(node.expression, /*contextualMapper*/ undefined);
                     let expressionElementType: Type;
-                    let nodeIsYieldStar = !!node.asteriskToken;
+                    const nodeIsYieldStar = !!node.asteriskToken;
                     if (nodeIsYieldStar) {
                         expressionElementType = checkElementTypeOfIterable(expressionType, node.expression);
                     }
@@ -10351,7 +10350,7 @@ namespace ts {
                     // has no explicit return type because the return type is directly computed
                     // from the yield expressions.
                     if (func.type) {
-                        let signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType;
+                        const signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType;
                         if (nodeIsYieldStar) {
                             checkTypeAssignableTo(expressionElementType, signatureElementType, node.expression, /*headMessage*/ undefined);
                         }
@@ -10368,8 +10367,8 @@ namespace ts {
 
         function checkConditionalExpression(node: ConditionalExpression, contextualMapper?: TypeMapper): Type {
             checkExpression(node.condition);
-            let type1 = checkExpression(node.whenTrue, contextualMapper);
-            let type2 = checkExpression(node.whenFalse, contextualMapper);
+            const type1 = checkExpression(node.whenTrue, contextualMapper);
+            const type2 = checkExpression(node.whenFalse, contextualMapper);
             return getUnionType([type1, type2]);
         }
 
@@ -10387,15 +10386,15 @@ namespace ts {
         }
 
         function checkExpressionWithContextualType(node: Expression, contextualType: Type, contextualMapper?: TypeMapper): Type {
-            let saveContextualType = node.contextualType;
+            const saveContextualType = node.contextualType;
             node.contextualType = contextualType;
-            let result = checkExpression(node, contextualMapper);
+            const result = checkExpression(node, contextualMapper);
             node.contextualType = saveContextualType;
             return result;
         }
 
         function checkExpressionCached(node: Expression, contextualMapper?: TypeMapper): Type {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 links.resolvedType = checkExpression(node, contextualMapper);
             }
@@ -10424,17 +10423,17 @@ namespace ts {
                 checkComputedPropertyName(<ComputedPropertyName>node.name);
             }
 
-            let uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper);
+            const uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper);
             return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper);
         }
 
         function instantiateTypeWithSingleGenericCallSignature(node: Expression | MethodDeclaration, type: Type, contextualMapper?: TypeMapper) {
             if (isInferentialContext(contextualMapper)) {
-                let signature = getSingleCallSignature(type);
+                const signature = getSingleCallSignature(type);
                 if (signature && signature.typeParameters) {
-                    let contextualType = getContextualType(<Expression>node);
+                    const contextualType = getContextualType(<Expression>node);
                     if (contextualType) {
-                        let contextualSignature = getSingleCallSignature(contextualType);
+                        const contextualSignature = getSingleCallSignature(contextualType);
                         if (contextualSignature && !contextualSignature.typeParameters) {
                             return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper));
                         }
@@ -10458,7 +10457,7 @@ namespace ts {
                 type = checkQualifiedName(<QualifiedName>node);
             }
             else {
-                let uninstantiatedType = checkExpressionWorker(<Expression>node, contextualMapper);
+                const uninstantiatedType = checkExpressionWorker(<Expression>node, contextualMapper);
                 type = instantiateTypeWithSingleGenericCallSignature(<Expression>node, uninstantiatedType, contextualMapper);
             }
 
@@ -10467,7 +10466,7 @@ namespace ts {
                 // - 'left' in property access
                 // - 'object' in indexed access
                 // - target in rhs of import statement
-                let ok =
+                const ok =
                     (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).expression === node) ||
                     (node.parent.kind === SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).expression === node) ||
                     ((node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName) && isInRightSideOfImportOrExportAssignment(<Identifier>node));
@@ -10621,7 +10620,7 @@ namespace ts {
         function getTypePredicateParameterIndex(parameterList: NodeArray<ParameterDeclaration>, parameter: Identifier): number {
             if (parameterList) {
                 for (let i = 0; i < parameterList.length; i++) {
-                    let param = parameterList[i];
+                    const param = parameterList[i];
                     if (param.name.kind === SyntaxKind.Identifier &&
                         (<Identifier>param.name).text === parameter.text) {
 
@@ -10664,8 +10663,8 @@ namespace ts {
 
             if (node.type) {
                 if (node.type.kind === SyntaxKind.TypePredicate) {
-                    let typePredicate = getSignatureFromDeclaration(node).typePredicate;
-                    let typePredicateNode = <TypePredicateNode>node.type;
+                    const typePredicate = getSignatureFromDeclaration(node).typePredicate;
+                    const typePredicateNode = <TypePredicateNode>node.type;
                     if (isInLegalTypePredicatePosition(typePredicateNode)) {
                         if (typePredicate.parameterIndex >= 0) {
                             if (node.parameters[typePredicate.parameterIndex].dotDotDotToken) {
@@ -10688,7 +10687,7 @@ namespace ts {
                                     param.name.kind === SyntaxKind.ArrayBindingPattern) {
 
                                     (function checkBindingPattern(pattern: BindingPattern) {
-                                        for (let element of pattern.elements) {
+                                        for (const element of pattern.elements) {
                                             if (element.name.kind === SyntaxKind.Identifier &&
                                                 (<Identifier>element.name).text === typePredicate.parameterName) {
 
@@ -10739,13 +10738,13 @@ namespace ts {
 
                 if (node.type) {
                     if (languageVersion >= ScriptTarget.ES6 && isSyntacticallyValidGenerator(node)) {
-                        let returnType = getTypeFromTypeNode(node.type);
+                        const returnType = getTypeFromTypeNode(node.type);
                         if (returnType === voidType) {
                             error(node.type, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
                         }
                         else {
-                            let generatorElementType = getElementTypeOfIterableIterator(returnType) || anyType;
-                            let iterableIteratorInstantiation = createIterableIteratorType(generatorElementType);
+                            const generatorElementType = getElementTypeOfIterableIterator(returnType) || anyType;
+                            const iterableIteratorInstantiation = createIterableIteratorType(generatorElementType);
 
                             // Naively, one could check that IterableIterator<any> is assignable to the return type annotation.
                             // However, that would not catch the error in the following case.
@@ -10764,7 +10763,7 @@ namespace ts {
 
         function checkTypeForDuplicateIndexSignatures(node: Node) {
             if (node.kind === SyntaxKind.InterfaceDeclaration) {
-                let nodeSymbol = getSymbolOfNode(node);
+                const nodeSymbol = getSymbolOfNode(node);
                 // in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration
                 // to prevent this run check only for the first declaration of a given kind
                 if (nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) {
@@ -10775,12 +10774,12 @@ namespace ts {
             // TypeScript 1.0 spec (April 2014)
             // 3.7.4: An object type can contain at most one string index signature and one numeric index signature.
             // 8.5: A class declaration can have at most one string index member declaration and one numeric index member declaration
-            let indexSymbol = getIndexSymbol(getSymbolOfNode(node));
+            const indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol) {
                 let seenNumericIndexer = false;
                 let seenStringIndexer = false;
-                for (let decl of indexSymbol.declarations) {
-                    let declaration = <SignatureDeclaration>decl;
+                for (const decl of indexSymbol.declarations) {
+                    const declaration = <SignatureDeclaration>decl;
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         switch (declaration.parameters[0].type.kind) {
                             case SyntaxKind.StringKeyword:
@@ -10834,8 +10833,8 @@ namespace ts {
 
             checkSourceElement(node.body);
 
-            let symbol = getSymbolOfNode(node);
-            let firstDeclaration = getDeclarationOfKind(symbol, node.kind);
+            const symbol = getSymbolOfNode(node);
+            const firstDeclaration = getDeclarationOfKind(symbol, node.kind);
 
             // Only type check the symbol once
             if (node === firstDeclaration) {
@@ -10890,11 +10889,11 @@ namespace ts {
             // TS 1.0 spec (April 2014): 8.3.2
             // Constructors of classes with no extends clause may not contain super calls, whereas
             // constructors of derived classes must contain at least one super call somewhere in their function body.
-            let containingClassDecl = <ClassDeclaration>node.parent;
+            const containingClassDecl = <ClassDeclaration>node.parent;
             if (getClassExtendsHeritageClauseElement(containingClassDecl)) {
-                let containingClassSymbol = getSymbolOfNode(containingClassDecl);
-                let containingClassInstanceType = <InterfaceType>getDeclaredTypeOfSymbol(containingClassSymbol);
-                let baseConstructorType = getBaseConstructorTypeOfClass(containingClassInstanceType);
+                const containingClassSymbol = getSymbolOfNode(containingClassDecl);
+                const containingClassInstanceType = <InterfaceType>getDeclaredTypeOfSymbol(containingClassSymbol);
+                const baseConstructorType = getBaseConstructorTypeOfClass(containingClassInstanceType);
 
                 if (containsSuperCall(node.body)) {
                     if (baseConstructorType === nullType) {
@@ -10906,16 +10905,16 @@ namespace ts {
                     // - The containing class is a derived class.
                     // - The constructor declares parameter properties
                     //   or the containing class declares instance member variables with initializers.
-                    let superCallShouldBeFirst =
+                    const superCallShouldBeFirst =
                         forEach((<ClassDeclaration>node.parent).members, isInstancePropertyWithInitializer) ||
                         forEach(node.parameters, p => p.flags & (NodeFlags.Public | NodeFlags.Private | NodeFlags.Protected));
 
                     // Skip past any prologue directives to find the first statement
                     // to ensure that it was a super call.
                     if (superCallShouldBeFirst) {
-                        let statements = (<Block>node.body).statements;
+                        const statements = (<Block>node.body).statements;
                         let superCallStatement: ExpressionStatement;
-                        for (let statement of statements) {
+                        for (const statement of statements) {
                             if (statement.kind === SyntaxKind.ExpressionStatement && isSuperCallExpression((<ExpressionStatement>statement).expression)) {
                                 superCallStatement = <ExpressionStatement>statement;
                                 break;
@@ -10945,23 +10944,30 @@ namespace ts {
                 checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
 
                 if (node.kind === SyntaxKind.GetAccessor) {
-                    if (!isInAmbientContext(node) && nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(<Block>node.body) || bodyContainsSingleThrowStatement(<Block>node.body))) {
-                        error(node.name, Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);
+                    if (!isInAmbientContext(node) && nodeIsPresent(node.body) && (node.flags & NodeFlags.HasImplicitReturn)) {
+                        if (node.flags & NodeFlags.HasExplicitReturn) {
+                            if (compilerOptions.noImplicitReturns) {
+                                error(node.name, Diagnostics.Not_all_code_paths_return_a_value);
+                            }
+                        }
+                        else {
+                            error(node.name, Diagnostics.A_get_accessor_must_return_a_value);
+                        }
                     }
                 }
 
                 if (!hasDynamicName(node)) {
                     // TypeScript 1.0 spec (April 2014): 8.4.3
                     // Accessors for the same member name must specify the same accessibility.
-                    let otherKind = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : SyntaxKind.GetAccessor;
-                    let otherAccessor = <AccessorDeclaration>getDeclarationOfKind(node.symbol, otherKind);
+                    const otherKind = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : SyntaxKind.GetAccessor;
+                    const otherAccessor = <AccessorDeclaration>getDeclarationOfKind(node.symbol, otherKind);
                     if (otherAccessor) {
                         if (((node.flags & NodeFlags.AccessibilityModifier) !== (otherAccessor.flags & NodeFlags.AccessibilityModifier))) {
                             error(node.name, Diagnostics.Getter_and_setter_accessors_do_not_agree_in_visibility);
                         }
 
-                        let currentAccessorType = getAnnotatedAccessorType(node);
-                        let otherAccessorType = getAnnotatedAccessorType(otherAccessor);
+                        const currentAccessorType = getAnnotatedAccessorType(node);
+                        const otherAccessorType = getAnnotatedAccessorType(otherAccessor);
                         // TypeScript 1.0 spec (April 2014): 4.5
                         // If both accessors include type annotations, the specified types must be identical.
                         if (currentAccessorType && otherAccessorType) {
@@ -10984,9 +10990,9 @@ namespace ts {
         function checkTypeArgumentConstraints(typeParameters: TypeParameter[], typeArguments: TypeNode[]): boolean {
             let result = true;
             for (let i = 0; i < typeParameters.length; i++) {
-                let constraint = getConstraintOfTypeParameter(typeParameters[i]);
+                const constraint = getConstraintOfTypeParameter(typeParameters[i]);
                 if (constraint) {
-                    let typeArgument = typeArguments[i];
+                    const typeArgument = typeArguments[i];
                     result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
                 }
             }
@@ -10995,13 +11001,13 @@ namespace ts {
 
         function checkTypeReferenceNode(node: TypeReferenceNode | ExpressionWithTypeArguments) {
             checkGrammarTypeArguments(node, node.typeArguments);
-            let type = getTypeFromTypeReference(node);
+            const type = getTypeFromTypeReference(node);
             if (type !== unknownType && node.typeArguments) {
                 // Do type argument local checks only if referenced type is successfully resolved
                 forEach(node.typeArguments, checkSourceElement);
                 if (produceDiagnostics) {
-                    let symbol = getNodeLinks(node).resolvedSymbol;
-                    let typeParameters = symbol.flags & SymbolFlags.TypeAlias ? getSymbolLinks(symbol).typeParameters : (<TypeReference>type).target.localTypeParameters;
+                    const symbol = getNodeLinks(node).resolvedSymbol;
+                    const typeParameters = symbol.flags & SymbolFlags.TypeAlias ? getSymbolLinks(symbol).typeParameters : (<TypeReference>type).target.localTypeParameters;
                     checkTypeArgumentConstraints(typeParameters, node.typeArguments);
                 }
             }
@@ -11014,7 +11020,7 @@ namespace ts {
         function checkTypeLiteral(node: TypeLiteralNode) {
             forEach(node.members, checkSourceElement);
             if (produceDiagnostics) {
-                let type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
+                const type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
                 checkIndexConstraints(type);
                 checkTypeForDuplicateIndexSignatures(node);
             }
@@ -11026,7 +11032,7 @@ namespace ts {
 
         function checkTupleType(node: TupleTypeNode) {
             // Grammar checking
-            let hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes);
+            const hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes);
             if (!hasErrorFromDisallowedTrailingComma && node.elementTypes.length === 0) {
                 grammarErrorOnNode(node, Diagnostics.A_tuple_type_element_list_cannot_be_empty);
             }
@@ -11046,7 +11052,7 @@ namespace ts {
             if (!produceDiagnostics) {
                 return;
             }
-            let signature = getSignatureFromDeclaration(signatureDeclarationNode);
+            const signature = getSignatureFromDeclaration(signatureDeclarationNode);
             if (!signature.hasStringLiterals) {
                 return;
             }
@@ -11066,16 +11072,16 @@ namespace ts {
             // Use declaring type to obtain full list of signatures.
             if (!signatureDeclarationNode.name && signatureDeclarationNode.parent && signatureDeclarationNode.parent.kind === SyntaxKind.InterfaceDeclaration) {
                 Debug.assert(signatureDeclarationNode.kind === SyntaxKind.CallSignature || signatureDeclarationNode.kind === SyntaxKind.ConstructSignature);
-                let signatureKind = signatureDeclarationNode.kind === SyntaxKind.CallSignature ? SignatureKind.Call : SignatureKind.Construct;
-                let containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent);
-                let containingType = getDeclaredTypeOfSymbol(containingSymbol);
+                const signatureKind = signatureDeclarationNode.kind === SyntaxKind.CallSignature ? SignatureKind.Call : SignatureKind.Construct;
+                const containingSymbol = getSymbolOfNode(signatureDeclarationNode.parent);
+                const containingType = getDeclaredTypeOfSymbol(containingSymbol);
                 signaturesToCheck = getSignaturesOfType(containingType, signatureKind);
             }
             else {
                 signaturesToCheck = getSignaturesOfSymbol(getSymbolOfNode(signatureDeclarationNode));
             }
 
-            for (let otherSignature of signaturesToCheck) {
+            for (const otherSignature of signaturesToCheck) {
                 if (!otherSignature.hasStringLiterals && isSignatureAssignableTo(signature, otherSignature)) {
                     return;
                 }
@@ -11114,19 +11120,19 @@ namespace ts {
                 // The caveat is that if some overloads are defined in lib.d.ts, we don't want to
                 // report the errors on those. To achieve this, we will say that the implementation is
                 // the canonical signature only if it is in the same container as the first overload
-                let implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent;
+                const implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent;
                 return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
             }
 
             function checkFlagAgreementBetweenOverloads(overloads: Declaration[], implementation: FunctionLikeDeclaration, flagsToCheck: NodeFlags, someOverloadFlags: NodeFlags, allOverloadFlags: NodeFlags): void {
                 // Error if some overloads have a flag that is not shared by all overloads. To find the
                 // deviations, we XOR someOverloadFlags with allOverloadFlags
-                let someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
+                const someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
                 if (someButNotAllOverloadFlags !== 0) {
-                    let canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
+                    const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck);
 
                     forEach(overloads, o => {
-                        let deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags;
+                        const deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags;
                         if (deviation & NodeFlags.Export) {
                             error(o.name, Diagnostics.Overload_signatures_must_all_be_exported_or_not_exported);
                         }
@@ -11145,9 +11151,9 @@ namespace ts {
 
             function checkQuestionTokenAgreementBetweenOverloads(overloads: Declaration[], implementation: FunctionLikeDeclaration, someHaveQuestionToken: boolean, allHaveQuestionToken: boolean): void {
                 if (someHaveQuestionToken !== allHaveQuestionToken) {
-                    let canonicalHasQuestionToken = hasQuestionToken(getCanonicalOverload(overloads, implementation));
+                    const canonicalHasQuestionToken = hasQuestionToken(getCanonicalOverload(overloads, implementation));
                     forEach(overloads, o => {
-                        let deviation = hasQuestionToken(o) !== canonicalHasQuestionToken;
+                        const deviation = hasQuestionToken(o) !== canonicalHasQuestionToken;
                         if (deviation) {
                             error(o.name, Diagnostics.Overload_signatures_must_all_be_optional_or_required);
                         }
@@ -11155,7 +11161,7 @@ namespace ts {
                 }
             }
 
-            let flagsToCheck: NodeFlags = NodeFlags.Export | NodeFlags.Ambient | NodeFlags.Private | NodeFlags.Protected | NodeFlags.Abstract;
+            const flagsToCheck: NodeFlags = NodeFlags.Export | NodeFlags.Ambient | NodeFlags.Private | NodeFlags.Protected | NodeFlags.Abstract;
             let someNodeFlags: NodeFlags = 0;
             let allNodeFlags = flagsToCheck;
             let someHaveQuestionToken = false;
@@ -11165,8 +11171,8 @@ namespace ts {
             let lastSeenNonAmbientDeclaration: FunctionLikeDeclaration;
             let previousDeclaration: FunctionLikeDeclaration;
 
-            let declarations = symbol.declarations;
-            let isConstructor = (symbol.flags & SymbolFlags.Constructor) !== 0;
+            const declarations = symbol.declarations;
+            const isConstructor = (symbol.flags & SymbolFlags.Constructor) !== 0;
 
             function reportImplementationExpectedError(node: FunctionLikeDeclaration): void {
                 if (node.name && nodeIsMissing(node.name)) {
@@ -11174,7 +11180,7 @@ namespace ts {
                 }
 
                 let seen = false;
-                let subsequentNode = forEachChild(node.parent, c => {
+                const subsequentNode = forEachChild(node.parent, c => {
                     if (seen) {
                         return c;
                     }
@@ -11184,13 +11190,13 @@ namespace ts {
                 });
                 if (subsequentNode) {
                     if (subsequentNode.kind === node.kind) {
-                        let errorNode: Node = (<FunctionLikeDeclaration>subsequentNode).name || subsequentNode;
+                        const errorNode: Node = (<FunctionLikeDeclaration>subsequentNode).name || subsequentNode;
                         // TODO(jfreeman): These are methods, so handle computed name case
                         if (node.name && (<FunctionLikeDeclaration>subsequentNode).name && (<Identifier>node.name).text === (<Identifier>(<FunctionLikeDeclaration>subsequentNode).name).text) {
                             // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members
                             Debug.assert(node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature);
                             Debug.assert((node.flags & NodeFlags.Static) !== (subsequentNode.flags & NodeFlags.Static));
-                            let diagnostic = node.flags & NodeFlags.Static ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static;
+                            const diagnostic = node.flags & NodeFlags.Static ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static;
                             error(errorNode, diagnostic);
                             return;
                         }
@@ -11200,7 +11206,7 @@ namespace ts {
                         }
                     }
                 }
-                let errorNode: Node = node.name || node;
+                const errorNode: Node = node.name || node;
                 if (isConstructor) {
                     error(errorNode, Diagnostics.Constructor_implementation_is_missing);
                 }
@@ -11218,13 +11224,13 @@ namespace ts {
 
             // when checking exported function declarations across modules check only duplicate implementations
             // names and consistency of modifiers are verified when we check local symbol
-            let isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & SymbolFlags.Module;
+            const isExportSymbolInsideModule = symbol.parent && symbol.parent.flags & SymbolFlags.Module;
             let duplicateFunctionDeclaration = false;
             let multipleConstructorImplementation = false;
-            for (let current of declarations) {
-                let node = <FunctionLikeDeclaration>current;
-                let inAmbientContext = isInAmbientContext(node);
-                let inAmbientContextOrInterface = node.parent.kind === SyntaxKind.InterfaceDeclaration || node.parent.kind === SyntaxKind.TypeLiteral || inAmbientContext;
+            for (const current of declarations) {
+                const node = <FunctionLikeDeclaration>current;
+                const inAmbientContext = isInAmbientContext(node);
+                const inAmbientContextOrInterface = node.parent.kind === SyntaxKind.InterfaceDeclaration || node.parent.kind === SyntaxKind.TypeLiteral || inAmbientContext;
                 if (inAmbientContextOrInterface) {
                     // check if declarations are consecutive only if they are non-ambient
                     // 1. ambient declarations can be interleaved
@@ -11237,7 +11243,7 @@ namespace ts {
                 }
 
                 if (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature || node.kind === SyntaxKind.Constructor) {
-                    let currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
+                    const currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
                     someNodeFlags |= currentNodeFlags;
                     allNodeFlags &= currentNodeFlags;
                     someHaveQuestionToken = someHaveQuestionToken || hasQuestionToken(node);
@@ -11295,8 +11301,8 @@ namespace ts {
                 checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken);
 
                 if (bodyDeclaration) {
-                    let signatures = getSignaturesOfSymbol(symbol);
-                    let bodySignature = getSignatureFromDeclaration(bodyDeclaration);
+                    const signatures = getSignaturesOfSymbol(symbol);
+                    const bodySignature = getSignatureFromDeclaration(bodyDeclaration);
                     // If the implementation signature has string literals, we will have reported an error in
                     // checkSpecializedSignatureDeclaration
                     if (!bodySignature.hasStringLiterals) {
@@ -11314,7 +11320,7 @@ namespace ts {
                         // function g(x: string, y: string) { }
                         //
                         // The implementation is completely unrelated to the specialized signature, yet we do not check this.
-                        for (let signature of signatures) {
+                        for (const signature of signatures) {
                             if (!signature.hasStringLiterals && !isSignatureAssignableTo(bodySignature, signature)) {
                                 error(signature.declaration, Diagnostics.Overload_signature_is_not_compatible_with_function_implementation);
                                 break;
@@ -11352,9 +11358,9 @@ namespace ts {
             let exportedDeclarationSpaces = SymbolFlags.None;
             let nonExportedDeclarationSpaces = SymbolFlags.None;
             let defaultExportedDeclarationSpaces = SymbolFlags.None;
-            for (let d of symbol.declarations) {
-                let declarationSpaces = getDeclarationSpaces(d);
-                let effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, NodeFlags.Export | NodeFlags.Default);
+            for (const d of symbol.declarations) {
+                const declarationSpaces = getDeclarationSpaces(d);
+                const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, NodeFlags.Export | NodeFlags.Default);
 
                 if (effectiveDeclarationFlags & NodeFlags.Export) {
                     if (effectiveDeclarationFlags & NodeFlags.Default) {
@@ -11370,15 +11376,15 @@ namespace ts {
             }
 
             // Spaces for anyting not declared a 'default export'.
-            let nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
+            const nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
 
-            let commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
-            let commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
+            const commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
+            const commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
 
             if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {
                 // declaration spaces for exported and non-exported declarations intersect
-                for (let d of symbol.declarations) {
-                    let declarationSpaces = getDeclarationSpaces(d);
+                for (const d of symbol.declarations) {
+                    const declarationSpaces = getDeclarationSpaces(d);
 
                     // Only error on the declarations that conributed to the intersecting spaces.
                     if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {
@@ -11403,7 +11409,7 @@ namespace ts {
                         return SymbolFlags.ExportType | SymbolFlags.ExportValue;
                     case SyntaxKind.ImportEqualsDeclaration:
                         let result: SymbolFlags = 0;
-                        let target = resolveAlias(getSymbolOfNode(d));
+                        const target = resolveAlias(getSymbolOfNode(d));
                         forEach(target.declarations, d => { result |= getDeclarationSpaces(d); });
                         return result;
                     default:
@@ -11453,32 +11459,32 @@ namespace ts {
                 return (<GenericType>promise).typeArguments[0];
             }
 
-            let globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType();
+            const globalPromiseLikeType = getInstantiatedGlobalPromiseLikeType();
             if (globalPromiseLikeType === emptyObjectType || !isTypeAssignableTo(promise, globalPromiseLikeType)) {
                 return undefined;
             }
 
-            let thenFunction = getTypeOfPropertyOfType(promise, "then");
+            const thenFunction = getTypeOfPropertyOfType(promise, "then");
             if (thenFunction && (thenFunction.flags & TypeFlags.Any)) {
                 return undefined;
             }
 
-            let thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, SignatureKind.Call) : emptyArray;
+            const thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, SignatureKind.Call) : emptyArray;
             if (thenSignatures.length === 0) {
                 return undefined;
             }
 
-            let onfulfilledParameterType = getUnionType(map(thenSignatures, getTypeOfFirstParameterOfSignature));
+            const onfulfilledParameterType = getUnionType(map(thenSignatures, getTypeOfFirstParameterOfSignature));
             if (onfulfilledParameterType.flags & TypeFlags.Any) {
                 return undefined;
             }
 
-            let onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call);
+            const onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, SignatureKind.Call);
             if (onfulfilledParameterSignatures.length === 0) {
                 return undefined;
             }
 
-            let valueParameterType = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature));
+            const valueParameterType = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature));
             return valueParameterType;
         }
 
@@ -11502,15 +11508,15 @@ namespace ts {
 
             function checkAwaitedTypeWorker(type: Type): Type {
                 if (type.flags & TypeFlags.Union) {
-                    let types: Type[] = [];
-                    for (let constituentType of (<UnionType>type).types) {
+                    const types: Type[] = [];
+                    for (const constituentType of (<UnionType>type).types) {
                         types.push(checkAwaitedTypeWorker(constituentType));
                     }
 
                     return getUnionType(types);
                 }
                 else {
-                    let promisedType = getPromisedType(type);
+                    const promisedType = getPromisedType(type);
                     if (promisedType === undefined) {
                         // The type was not a PromiseLike, so it could not be unwrapped any further.
                         // As long as the type does not have a callable "then" property, it is
@@ -11577,7 +11583,7 @@ namespace ts {
                         // Keep track of the type we're about to unwrap to avoid bad recursive promise types.
                         // See the comments above for more information.
                         awaitedTypeStack.push(type.id);
-                        let awaitedType = checkAwaitedTypeWorker(promisedType);
+                        const awaitedType = checkAwaitedTypeWorker(promisedType);
                         awaitedTypeStack.pop();
                         return awaitedType;
                     }
@@ -11599,7 +11605,7 @@ namespace ts {
           * callable `then` signature.
           */
         function checkAsyncFunctionReturnType(node: FunctionLikeDeclaration): Type {
-            let globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType();
+            const globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType();
             if (globalPromiseConstructorLikeType === emptyObjectType) {
                 // If we couldn't resolve the global PromiseConstructorLike type we cannot verify
                 // compatibility with __awaiter.
@@ -11633,16 +11639,16 @@ namespace ts {
             // When we get the type of the `Promise` symbol here, we get the type of the static
             // side of the `Promise` class, which would be `{ new <T>(...): Promise<T> }`.
 
-            let promiseType = getTypeFromTypeNode(node.type);
+            const promiseType = getTypeFromTypeNode(node.type);
             if (promiseType === unknownType && compilerOptions.isolatedModules) {
                 // If we are compiling with isolatedModules, we may not be able to resolve the
                 // type as a value. As such, we will just return unknownType;
                 return unknownType;
             }
 
-            let promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
+            const promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
             if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
-                let typeName = promiseConstructor
+                const typeName = promiseConstructor
                     ? symbolToString(promiseConstructor)
                     : typeToString(promiseType);
                 error(node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeName);
@@ -11650,15 +11656,15 @@ namespace ts {
             }
 
             // Validate the promise constructor type.
-            let promiseConstructorType = getTypeOfSymbol(promiseConstructor);
+            const promiseConstructorType = getTypeOfSymbol(promiseConstructor);
             if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type)) {
                 return unknownType;
             }
 
             // Verify there is no local declaration that could collide with the promise constructor.
-            let promiseName = getEntityNameFromTypeNode(node.type);
-            let root = getFirstIdentifier(promiseName);
-            let rootSymbol = getSymbol(node.locals, root.text, SymbolFlags.Value);
+            const promiseName = getEntityNameFromTypeNode(node.type);
+            const root = getFirstIdentifier(promiseName);
+            const rootSymbol = getSymbol(node.locals, root.text, SymbolFlags.Value);
             if (rootSymbol) {
                 error(rootSymbol.valueDeclaration, Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions,
                     root.text,
@@ -11672,19 +11678,19 @@ namespace ts {
 
         /** Check a decorator */
         function checkDecorator(node: Decorator): void {
-            let signature = getResolvedSignature(node);
-            let returnType = getReturnTypeOfSignature(signature);
+            const signature = getResolvedSignature(node);
+            const returnType = getReturnTypeOfSignature(signature);
             if (returnType.flags & TypeFlags.Any) {
                 return;
             }
 
             let expectedReturnType: Type;
-            let headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
+            const headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
             let errorInfo: DiagnosticMessageChain;
             switch (node.parent.kind) {
                 case SyntaxKind.ClassDeclaration:
-                    let classSymbol = getSymbolOfNode(node.parent);
-                    let classConstructorType = getTypeOfSymbol(classSymbol);
+                    const classSymbol = getSymbolOfNode(node.parent);
+                    const classConstructorType = getTypeOfSymbol(classSymbol);
                     expectedReturnType = getUnionType([classConstructorType, voidType]);
                     break;
 
@@ -11706,8 +11712,8 @@ namespace ts {
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.GetAccessor:
                 case SyntaxKind.SetAccessor:
-                    let methodType = getTypeOfNode(node.parent);
-                    let descriptorType = createTypedPropertyDescriptorType(methodType);
+                    const methodType = getTypeOfNode(node.parent);
+                    const descriptorType = createTypedPropertyDescriptorType(methodType);
                     expectedReturnType = getUnionType([descriptorType, voidType]);
                     break;
             }
@@ -11726,13 +11732,13 @@ namespace ts {
             // as if it were an expression so that we can emit the type in a value position when we
             // serialize the type metadata.
             if (node && node.kind === SyntaxKind.TypeReference) {
-                let root = getFirstIdentifier((<TypeReferenceNode>node).typeName);
-                let meaning = root.parent.kind === SyntaxKind.TypeReference ? SymbolFlags.Type : SymbolFlags.Namespace;
+                const root = getFirstIdentifier((<TypeReferenceNode>node).typeName);
+                const meaning = root.parent.kind === SyntaxKind.TypeReference ? SymbolFlags.Type : SymbolFlags.Namespace;
                 // Resolve type so we know which symbol is referenced
-                let rootSymbol = resolveName(root, root.text, meaning | SymbolFlags.Alias, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+                const rootSymbol = resolveName(root, root.text, meaning | SymbolFlags.Alias, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
                 // Resolved symbol is alias
                 if (rootSymbol && rootSymbol.flags & SymbolFlags.Alias) {
-                    let aliasTarget = resolveAlias(rootSymbol);
+                    const aliasTarget = resolveAlias(rootSymbol);
                     // If alias has value symbol - mark alias as referenced
                     if (aliasTarget.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol))) {
                         markAliasSymbolAsReferenced(rootSymbol);
@@ -11768,7 +11774,7 @@ namespace ts {
         /** Checks the type annotation of the parameters of a function/method or the constructor of a class as expressions */
         function checkParameterTypeAnnotationsAsExpressions(node: FunctionLikeDeclaration) {
             // ensure all type annotations with a value declaration are checked as an expression
-            for (let parameter of node.parameters) {
+            for (const parameter of node.parameters) {
                 checkTypeAnnotationAsExpression(parameter);
             }
         }
@@ -11793,7 +11799,7 @@ namespace ts {
                 // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator.
                 switch (node.kind) {
                     case SyntaxKind.ClassDeclaration:
-                        let constructor = getFirstConstructorWithBody(<ClassDeclaration>node);
+                        const constructor = getFirstConstructorWithBody(<ClassDeclaration>node);
                         if (constructor) {
                             checkParameterTypeAnnotationsAsExpressions(constructor);
                         }
@@ -11833,7 +11839,7 @@ namespace ts {
         function checkFunctionLikeDeclaration(node: FunctionLikeDeclaration): void {
             checkDecorators(node);
             checkSignatureDeclaration(node);
-            let isAsync = isAsyncFunctionLike(node);
+            const isAsync = isAsyncFunctionLike(node);
             if (isAsync) {
                 emitAwaiter = true;
             }
@@ -11851,10 +11857,10 @@ namespace ts {
                 // first we want to check the local symbol that contain this declaration
                 // - if node.localSymbol !== undefined - this is current declaration is exported and localSymbol points to the local symbol
                 // - if node.localSymbol === undefined - this node is non-exported so we can just pick the result of getSymbolOfNode
-                let symbol = getSymbolOfNode(node);
-                let localSymbol = node.localSymbol || symbol;
+                const symbol = getSymbolOfNode(node);
+                const localSymbol = node.localSymbol || symbol;
 
-                let firstDeclaration = forEach(symbol.declarations,
+                const firstDeclaration = forEach(symbol.declarations,
                     // Get first non javascript function declaration
                     declaration => declaration.kind === node.kind && !isJavaScript(getSourceFile(declaration).fileName) ?
                         declaration : undefined);
@@ -11875,13 +11881,13 @@ namespace ts {
 
             checkSourceElement(node.body);
             if (node.type && !isAccessor(node.kind) && !node.asteriskToken) {
-                let returnType = getTypeFromTypeNode(node.type);
+                const returnType = getTypeFromTypeNode(node.type);
                 let promisedType: Type;
                 if (isAsync) {
                     promisedType = checkAsyncFunctionReturnType(node);
                 }
 
-                checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType);
+                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType);
             }
 
             if (produceDiagnostics && !node.type) {
@@ -11945,7 +11951,7 @@ namespace ts {
                 return false;
             }
 
-            let root = getRootDeclaration(node);
+            const root = getRootDeclaration(node);
             if (root.kind === SyntaxKind.Parameter && nodeIsMissing((<FunctionLikeDeclaration>root.parent).body)) {
                 // just an overload - no codegen impact
                 return false;
@@ -11965,7 +11971,7 @@ namespace ts {
             let current = node;
             while (current) {
                 if (getNodeCheckFlags(current) & NodeCheckFlags.CaptureThis) {
-                    let isDeclaration = node.kind !== SyntaxKind.Identifier;
+                    const isDeclaration = node.kind !== SyntaxKind.Identifier;
                     if (isDeclaration) {
                         error((<Declaration>node).name, Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference);
                     }
@@ -11984,14 +11990,14 @@ namespace ts {
             }
 
             // bubble up and find containing type
-            let enclosingClass = getContainingClass(node);
+            const enclosingClass = getContainingClass(node);
             // if containing type was not found or it is ambient - exit (no codegen)
             if (!enclosingClass || isInAmbientContext(enclosingClass)) {
                 return;
             }
 
             if (getClassExtendsHeritageClauseElement(enclosingClass)) {
-                let isDeclaration = node.kind !== SyntaxKind.Identifier;
+                const isDeclaration = node.kind !== SyntaxKind.Identifier;
                 if (isDeclaration) {
                     error(node, Diagnostics.Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference);
                 }
@@ -12012,7 +12018,7 @@ namespace ts {
             }
 
             // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent
-            let parent = getDeclarationContainer(node);
+            const parent = getDeclarationContainer(node);
             if (parent.kind === SyntaxKind.SourceFile && isExternalModule(<SourceFile>parent)) {
                 // If the declaration happens to be in external module, report error that require and exports are reserved keywords
                 error(name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,
@@ -12035,15 +12041,15 @@ namespace ts {
             // A non-initialized declaration is a no-op as the block declaration will resolve before the var
             // declaration. the problem is if the declaration has an initializer. this will act as a write to the
             // block declared value. this is fine for let, but not const.
-            // Only consider declarations with initializers, uninitialized let declarations will not
+            // Only consider declarations with initializers, uninitialized const declarations will not
             // step on a let/const variable.
-            // Do not consider let and const declarations, as duplicate block-scoped declarations
+            // Do not consider const and const declarations, as duplicate block-scoped declarations
             // are handled by the binder.
-            // We are only looking for let declarations that step on let\const declarations from a
+            // We are only looking for const declarations that step on let\const declarations from a
             // different scope. e.g.:
             //      {
             //          const x = 0; // localDeclarationSymbol obtained after name resolution will correspond to this declaration
-            //          let x = 0; // symbol for this declaration will be 'symbol'
+            //          const x = 0; // symbol for this declaration will be 'symbol'
             //      }
 
             // skip block-scoped variables and parameters
@@ -12058,22 +12064,22 @@ namespace ts {
                 return;
             }
 
-            let symbol = getSymbolOfNode(node);
+            const symbol = getSymbolOfNode(node);
             if (symbol.flags & SymbolFlags.FunctionScopedVariable) {
-                let localDeclarationSymbol = resolveName(node, (<Identifier>node.name).text, SymbolFlags.Variable, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
+                const localDeclarationSymbol = resolveName(node, (<Identifier>node.name).text, SymbolFlags.Variable, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined);
                 if (localDeclarationSymbol &&
                     localDeclarationSymbol !== symbol &&
                     localDeclarationSymbol.flags & SymbolFlags.BlockScopedVariable) {
                     if (getDeclarationFlagsFromSymbol(localDeclarationSymbol) & NodeFlags.BlockScoped) {
-                        let varDeclList = getAncestor(localDeclarationSymbol.valueDeclaration, SyntaxKind.VariableDeclarationList);
-                        let container =
+                        const varDeclList = getAncestor(localDeclarationSymbol.valueDeclaration, SyntaxKind.VariableDeclarationList);
+                        const container =
                             varDeclList.parent.kind === SyntaxKind.VariableStatement && varDeclList.parent.parent
                                 ? varDeclList.parent.parent
                                 : undefined;
 
                         // names of block-scoped and function scoped variables can collide only
                         // if block scoped variable is defined in the function\module\source file scope (because of variable hoisting)
-                        let namesShareScope =
+                        const namesShareScope =
                             container &&
                             (container.kind === SyntaxKind.Block && isFunctionLike(container.parent) ||
                                 container.kind === SyntaxKind.ModuleBlock ||
@@ -12085,7 +12091,7 @@ namespace ts {
                         // otherwise if variable has an initializer - show error that initialization will fail
                         // since LHS will be block scoped name instead of function scoped
                         if (!namesShareScope) {
-                            let name = symbolToString(localDeclarationSymbol);
+                            const name = symbolToString(localDeclarationSymbol);
                             error(node, Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name);
                         }
                     }
@@ -12099,12 +12105,12 @@ namespace ts {
                 return;
             }
 
-            let func = getContainingFunction(node);
+            const func = getContainingFunction(node);
             visit(node.initializer);
 
             function visit(n: Node) {
                 if (n.kind === SyntaxKind.Identifier) {
-                    let referencedSymbol = getNodeLinks(n).resolvedSymbol;
+                    const referencedSymbol = getNodeLinks(n).resolvedSymbol;
                     // check FunctionLikeDeclaration.locals (stores parameters\function local variable)
                     // if it contains entry with a specified name and if this entry matches the resolved symbol
                     if (referencedSymbol && referencedSymbol !== unknownSymbol && getSymbol(func.locals, referencedSymbol.name, SymbolFlags.Value) === referencedSymbol) {
@@ -12159,8 +12165,8 @@ namespace ts {
                 }
                 return;
             }
-            let symbol = getSymbolOfNode(node);
-            let type = getTypeOfVariableOrParameterOrProperty(symbol);
+            const symbol = getSymbolOfNode(node);
+            const type = getTypeOfVariableOrParameterOrProperty(symbol);
             if (node === symbol.valueDeclaration) {
                 // Node is the primary declaration of the symbol, just validate the initializer
                 if (node.initializer) {
@@ -12171,7 +12177,7 @@ namespace ts {
             else {
                 // Node is a secondary declaration, check that type is identical to primary declaration and check that
                 // initializer is consistent with type associated with the node
-                let declarationType = getWidenedTypeForVariableLikeDeclaration(node);
+                const declarationType = getWidenedTypeForVariableLikeDeclaration(node);
                 if (type !== unknownType && declarationType !== unknownType && !isTypeIdenticalTo(type, declarationType)) {
                     error(node.name, Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, declarationNameToString(node.name), typeToString(type), typeToString(declarationType));
                 }
@@ -12293,8 +12299,8 @@ namespace ts {
                 checkForInOrForOfVariableDeclaration(node);
             }
             else {
-                let varExpr = <Expression>node.initializer;
-                let iteratedType = checkRightHandSideOfForOf(node.expression);
+                const varExpr = <Expression>node.initializer;
+                const iteratedType = checkRightHandSideOfForOf(node.expression);
 
                 // There may be a destructuring assignment on the left side
                 if (varExpr.kind === SyntaxKind.ArrayLiteralExpression || varExpr.kind === SyntaxKind.ObjectLiteralExpression) {
@@ -12304,7 +12310,7 @@ namespace ts {
                     checkDestructuringAssignment(varExpr, iteratedType || unknownType);
                 }
                 else {
-                    let leftType = checkExpression(varExpr);
+                    const leftType = checkExpression(varExpr);
                     checkReferenceExpression(varExpr, /*invalidReferenceMessage*/ Diagnostics.Invalid_left_hand_side_in_for_of_statement,
                         /*constantVariableMessage*/ Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant);
 
@@ -12331,7 +12337,7 @@ namespace ts {
             //   VarDecl must be a variable declaration without a type annotation that declares a variable of type Any,
             //   and Expr must be an expression of type Any, an object type, or a type parameter type.
             if (node.initializer.kind === SyntaxKind.VariableDeclarationList) {
-                let variable = (<VariableDeclarationList>node.initializer).declarations[0];
+                const variable = (<VariableDeclarationList>node.initializer).declarations[0];
                 if (variable && isBindingPattern(variable.name)) {
                     error(variable.name, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
                 }
@@ -12343,8 +12349,8 @@ namespace ts {
                 // for (Var in Expr) Statement
                 //   Var must be an expression classified as a reference of type Any or the String primitive type,
                 //   and Expr must be an expression of type Any, an object type, or a type parameter type.
-                let varExpr = <Expression>node.initializer;
-                let leftType = checkExpression(varExpr);
+                const varExpr = <Expression>node.initializer;
+                const leftType = checkExpression(varExpr);
                 if (varExpr.kind === SyntaxKind.ArrayLiteralExpression || varExpr.kind === SyntaxKind.ObjectLiteralExpression) {
                     error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
                 }
@@ -12357,7 +12363,7 @@ namespace ts {
                 }
             }
 
-            let rightType = checkExpression(node.expression);
+            const rightType = checkExpression(node.expression);
             // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved
             // in this case error about missing name is already reported - do not report extra one
             if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, TypeFlags.ObjectType | TypeFlags.TypeParameter)) {
@@ -12368,16 +12374,16 @@ namespace ts {
         }
 
         function checkForInOrForOfVariableDeclaration(iterationStatement: ForInStatement | ForOfStatement): void {
-            let variableDeclarationList = <VariableDeclarationList>iterationStatement.initializer;
+            const variableDeclarationList = <VariableDeclarationList>iterationStatement.initializer;
             // checkGrammarForInOrForOfStatement will check that there is exactly one declaration.
             if (variableDeclarationList.declarations.length >= 1) {
-                let decl = variableDeclarationList.declarations[0];
+                const decl = variableDeclarationList.declarations[0];
                 checkVariableDeclaration(decl);
             }
         }
 
         function checkRightHandSideOfForOf(rhsExpression: Expression): Type {
-            let expressionType = getTypeOfExpression(rhsExpression);
+            const expressionType = getTypeOfExpression(rhsExpression);
             return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true);
         }
 
@@ -12395,7 +12401,7 @@ namespace ts {
             }
 
             if (isArrayLikeType(inputType)) {
-                let indexType = getIndexTypeOfType(inputType, IndexKind.Number);
+                const indexType = getIndexTypeOfType(inputType, IndexKind.Number);
                 if (indexType) {
                     return indexType;
                 }
@@ -12409,7 +12415,7 @@ namespace ts {
          * When errorNode is undefined, it means we should not report any errors.
          */
         function checkElementTypeOfIterable(iterable: Type, errorNode: Node): Type {
-            let elementType = getElementTypeOfIterable(iterable, errorNode);
+            const elementType = getElementTypeOfIterable(iterable, errorNode);
             // Now even though we have extracted the iteratedType, we will have to validate that the type
             // passed in is actually an Iterable.
             if (errorNode && elementType) {
@@ -12445,7 +12451,7 @@ namespace ts {
                 return undefined;
             }
 
-            let typeAsIterable = <IterableOrIteratorType>type;
+            const typeAsIterable = <IterableOrIteratorType>type;
             if (!typeAsIterable.iterableElementType) {
                 // As an optimization, if the type is instantiated directly using the globalIterableType (Iterable<number>),
                 // then just grab its type argument.
@@ -12453,12 +12459,12 @@ namespace ts {
                     typeAsIterable.iterableElementType = (<GenericType>type).typeArguments[0];
                 }
                 else {
-                    let iteratorFunction = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator"));
+                    const iteratorFunction = getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator"));
                     if (isTypeAny(iteratorFunction)) {
                         return undefined;
                     }
 
-                    let iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray;
+                    const iteratorFunctionSignatures = iteratorFunction ? getSignaturesOfType(iteratorFunction, SignatureKind.Call) : emptyArray;
                     if (iteratorFunctionSignatures.length === 0) {
                         if (errorNode) {
                             error(errorNode, Diagnostics.Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator);
@@ -12491,7 +12497,7 @@ namespace ts {
                 return undefined;
             }
 
-            let typeAsIterator = <IterableOrIteratorType>type;
+            const typeAsIterator = <IterableOrIteratorType>type;
             if (!typeAsIterator.iteratorElementType) {
                 // As an optimization, if the type is instantiated directly using the globalIteratorType (Iterator<number>),
                 // then just grab its type argument.
@@ -12499,12 +12505,12 @@ namespace ts {
                     typeAsIterator.iteratorElementType = (<GenericType>type).typeArguments[0];
                 }
                 else {
-                    let iteratorNextFunction = getTypeOfPropertyOfType(type, "next");
+                    const iteratorNextFunction = getTypeOfPropertyOfType(type, "next");
                     if (isTypeAny(iteratorNextFunction)) {
                         return undefined;
                     }
 
-                    let iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray;
+                    const iteratorNextFunctionSignatures = iteratorNextFunction ? getSignaturesOfType(iteratorNextFunction, SignatureKind.Call) : emptyArray;
                     if (iteratorNextFunctionSignatures.length === 0) {
                         if (errorNode) {
                             error(errorNode, Diagnostics.An_iterator_must_have_a_next_method);
@@ -12512,12 +12518,12 @@ namespace ts {
                         return undefined;
                     }
 
-                    let iteratorNextResult = getUnionType(map(iteratorNextFunctionSignatures, getReturnTypeOfSignature));
+                    const iteratorNextResult = getUnionType(map(iteratorNextFunctionSignatures, getReturnTypeOfSignature));
                     if (isTypeAny(iteratorNextResult)) {
                         return undefined;
                     }
 
-                    let iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
+                    const iteratorNextValue = getTypeOfPropertyOfType(iteratorNextResult, "value");
                     if (!iteratorNextValue) {
                         if (errorNode) {
                             error(errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
@@ -12569,8 +12575,8 @@ namespace ts {
 
             // After we remove all types that are StringLike, we will know if there was a string constituent
             // based on whether the remaining type is the same as the initial type.
-            let arrayType = removeTypesFromUnionType(arrayOrStringType, TypeFlags.StringLike, /*isTypeOfKind*/ true, /*allowEmptyUnionResult*/ true);
-            let hasStringConstituent = arrayOrStringType !== arrayType;
+            const arrayType = removeTypesFromUnionType(arrayOrStringType, TypeFlags.StringLike, /*isTypeOfKind*/ true, /*allowEmptyUnionResult*/ true);
+            const hasStringConstituent = arrayOrStringType !== arrayType;
 
             let reportedError = false;
             if (hasStringConstituent) {
@@ -12592,7 +12598,7 @@ namespace ts {
                     // if the input type is number | string, we want to say that number is not an array type.
                     // But if the input was just number, we want to say that number is not an array type
                     // or a string type.
-                    let diagnostic = hasStringConstituent
+                    const diagnostic = hasStringConstituent
                         ? Diagnostics.Type_0_is_not_an_array_type
                         : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type;
                     error(errorNode, diagnostic, typeToString(arrayType));
@@ -12600,7 +12606,7 @@ namespace ts {
                 return hasStringConstituent ? stringType : unknownType;
             }
 
-            let arrayElementType = getIndexTypeOfType(arrayType, IndexKind.Number) || unknownType;
+            const arrayElementType = getIndexTypeOfType(arrayType, IndexKind.Number) || unknownType;
             if (hasStringConstituent) {
                 // This is just an optimization for the case where arrayOrStringType is string | string[]
                 if (arrayElementType.flags & TypeFlags.StringLike) {
@@ -12627,18 +12633,18 @@ namespace ts {
         function checkReturnStatement(node: ReturnStatement) {
             // Grammar checking
             if (!checkGrammarStatementInAmbientContext(node)) {
-                let functionBlock = getContainingFunction(node);
+                const functionBlock = getContainingFunction(node);
                 if (!functionBlock) {
                     grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
                 }
             }
 
             if (node.expression) {
-                let func = getContainingFunction(node);
+                const func = getContainingFunction(node);
                 if (func) {
-                    let signature = getSignatureFromDeclaration(func);
-                    let returnType = getReturnTypeOfSignature(signature);
-                    let exprType = checkExpressionCached(node.expression);
+                    const signature = getSignatureFromDeclaration(func);
+                    const returnType = getReturnTypeOfSignature(signature);
+                    const exprType = checkExpressionCached(node.expression);
 
                     if (func.asteriskToken) {
                         // A generator does not need its return expressions checked against its return type.
@@ -12658,8 +12664,8 @@ namespace ts {
                     }
                     else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) {
                         if (isAsyncFunctionLike(func)) {
-                            let promisedType = getPromisedType(returnType);
-                            let awaitedType = checkAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);
+                            const promisedType = getPromisedType(returnType);
+                            const awaitedType = checkAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member);
                             if (promisedType) {
                                 // If the function has a return type, but promisedType is
                                 // undefined, an error will be reported in checkAsyncFunctionReturnType
@@ -12694,7 +12700,7 @@ namespace ts {
             let firstDefaultClause: CaseOrDefaultClause;
             let hasDuplicateDefaultClause = false;
 
-            let expressionType = checkExpression(node.expression);
+            const expressionType = checkExpression(node.expression);
             forEach(node.caseBlock.clauses, clause => {
                 // Grammar check for duplicate default clauses, skip if we already report duplicate default clause
                 if (clause.kind === SyntaxKind.DefaultClause && !hasDuplicateDefaultClause) {
@@ -12702,19 +12708,19 @@ namespace ts {
                         firstDefaultClause = clause;
                     }
                     else {
-                        let sourceFile = getSourceFileOfNode(node);
-                        let start = skipTrivia(sourceFile.text, clause.pos);
-                        let end = clause.statements.length > 0 ? clause.statements[0].pos : clause.end;
+                        const sourceFile = getSourceFileOfNode(node);
+                        const start = skipTrivia(sourceFile.text, clause.pos);
+                        const end = clause.statements.length > 0 ? clause.statements[0].pos : clause.end;
                         grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
                         hasDuplicateDefaultClause = true;
                     }
                 }
 
                 if (produceDiagnostics && clause.kind === SyntaxKind.CaseClause) {
-                    let caseClause = <CaseClause>clause;
+                    const caseClause = <CaseClause>clause;
                     // TypeScript 1.0 spec (April 2014):5.9
                     // In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression.
-                    let caseType = checkExpression(caseClause.expression);
+                    const caseType = checkExpression(caseClause.expression);
                     if (!isTypeAssignableTo(expressionType, caseType)) {
                         // check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails
                         checkTypeAssignableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined);
@@ -12733,7 +12739,7 @@ namespace ts {
                         break;
                     }
                     if (current.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>current).label.text === node.label.text) {
-                        let sourceFile = getSourceFileOfNode(node);
+                        const sourceFile = getSourceFileOfNode(node);
                         grammarErrorOnNode(node.label, Diagnostics.Duplicate_label_0, getTextOfNodeFromSourceText(sourceFile.text, node.label));
                         break;
                     }
@@ -12763,7 +12769,7 @@ namespace ts {
             checkGrammarStatementInAmbientContext(node);
 
             checkBlock(node.tryBlock);
-            let catchClause = node.catchClause;
+            const catchClause = node.catchClause;
             if (catchClause) {
                 // Grammar checking
                 if (catchClause.variableDeclaration) {
@@ -12777,10 +12783,10 @@ namespace ts {
                         grammarErrorOnFirstToken(catchClause.variableDeclaration.initializer, Diagnostics.Catch_clause_variable_cannot_have_an_initializer);
                     }
                     else {
-                        let identifierName = (<Identifier>catchClause.variableDeclaration.name).text;
-                        let locals = catchClause.block.locals;
+                        const identifierName = (<Identifier>catchClause.variableDeclaration.name).text;
+                        const locals = catchClause.block.locals;
                         if (locals && hasProperty(locals, identifierName)) {
-                            let localSymbol = locals[identifierName];
+                            const localSymbol = locals[identifierName];
                             if (localSymbol && (localSymbol.flags & SymbolFlags.BlockScopedVariable) !== 0) {
                                 grammarErrorOnNode(localSymbol.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName);
                             }
@@ -12797,27 +12803,27 @@ namespace ts {
         }
 
         function checkIndexConstraints(type: Type) {
-            let declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, IndexKind.Number);
-            let declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, IndexKind.String);
+            const declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, IndexKind.Number);
+            const declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, IndexKind.String);
 
-            let stringIndexType = getIndexTypeOfType(type, IndexKind.String);
-            let numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
+            const stringIndexType = getIndexTypeOfType(type, IndexKind.String);
+            const numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
 
             if (stringIndexType || numberIndexType) {
                 forEach(getPropertiesOfObjectType(type), prop => {
-                    let propType = getTypeOfSymbol(prop);
+                    const propType = getTypeOfSymbol(prop);
                     checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, IndexKind.String);
                     checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, IndexKind.Number);
                 });
 
                 if (type.flags & TypeFlags.Class && isClassLike(type.symbol.valueDeclaration)) {
-                    let classDeclaration = <ClassLikeDeclaration>type.symbol.valueDeclaration;
-                    for (let member of classDeclaration.members) {
+                    const classDeclaration = <ClassLikeDeclaration>type.symbol.valueDeclaration;
+                    for (const member of classDeclaration.members) {
                         // Only process instance properties with computed names here.
                         // Static properties cannot be in conflict with indexers,
                         // and properties with literal names were already checked.
                         if (!(member.flags & NodeFlags.Static) && hasDynamicName(member)) {
-                            let propType = getTypeOfSymbol(member.symbol);
+                            const propType = getTypeOfSymbol(member.symbol);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, IndexKind.String);
                             checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, IndexKind.Number);
                         }
@@ -12830,7 +12836,7 @@ namespace ts {
                 errorNode = declaredNumberIndexer || declaredStringIndexer;
                 // condition 'errorNode === undefined' may appear if types does not declare nor string neither number indexer
                 if (!errorNode && (type.flags & TypeFlags.Interface)) {
-                    let someBaseTypeHasBothIndexers = forEach(getBaseTypes(<InterfaceType>type), base => getIndexTypeOfType(base, IndexKind.String) && getIndexTypeOfType(base, IndexKind.Number));
+                    const someBaseTypeHasBothIndexers = forEach(getBaseTypes(<InterfaceType>type), base => getIndexTypeOfType(base, IndexKind.String) && getIndexTypeOfType(base, IndexKind.Number));
                     errorNode = someBaseTypeHasBothIndexers ? undefined : type.symbol.declarations[0];
                 }
             }
@@ -12870,12 +12876,12 @@ namespace ts {
                     // for interfaces property and indexer might be inherited from different bases
                     // check if any base class already has both property and indexer.
                     // check should be performed only if 'type' is the first type that brings property\indexer together
-                    let someBaseClassHasBothPropertyAndIndexer = forEach(getBaseTypes(<InterfaceType>containingType), base => getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind));
+                    const someBaseClassHasBothPropertyAndIndexer = forEach(getBaseTypes(<InterfaceType>containingType), base => getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind));
                     errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0];
                 }
 
                 if (errorNode && !isTypeAssignableTo(propertyType, indexType)) {
-                    let errorMessage =
+                    const errorMessage =
                         indexKind === IndexKind.String
                             ? Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2
                             : Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2;
@@ -12902,7 +12908,7 @@ namespace ts {
         function checkTypeParameters(typeParameterDeclarations: TypeParameterDeclaration[]) {
             if (typeParameterDeclarations) {
                 for (let i = 0, n = typeParameterDeclarations.length; i < n; i++) {
-                    let node = typeParameterDeclarations[i];
+                    const node = typeParameterDeclarations[i];
                     checkTypeParameter(node);
 
                     if (produceDiagnostics) {
@@ -12940,22 +12946,22 @@ namespace ts {
             }
             checkTypeParameters(node.typeParameters);
             checkExportsOnMergedDeclarations(node);
-            let symbol = getSymbolOfNode(node);
-            let type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
-            let typeWithThis = getTypeWithThisArgument(type);
-            let staticType = <ObjectType>getTypeOfSymbol(symbol);
+            const symbol = getSymbolOfNode(node);
+            const type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
+            const typeWithThis = getTypeWithThisArgument(type);
+            const staticType = <ObjectType>getTypeOfSymbol(symbol);
 
-            let baseTypeNode = getClassExtendsHeritageClauseElement(node);
+            const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
                 emitExtends = emitExtends || !isInAmbientContext(node);
-                let baseTypes = getBaseTypes(type);
+                const baseTypes = getBaseTypes(type);
                 if (baseTypes.length && produceDiagnostics) {
-                    let baseType = baseTypes[0];
-                    let staticBaseType = getBaseConstructorTypeOfClass(type);
+                    const baseType = baseTypes[0];
+                    const staticBaseType = getBaseConstructorTypeOfClass(type);
                     checkSourceElement(baseTypeNode.expression);
                     if (baseTypeNode.typeArguments) {
                         forEach(baseTypeNode.typeArguments, checkSourceElement);
-                        for (let constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments)) {
+                        for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments)) {
                             if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) {
                                 break;
                             }
@@ -12970,7 +12976,7 @@ namespace ts {
                         // that all instantiated base constructor signatures return the same type. We can simply compare the type
                         // references (as opposed to checking the structure of the types) because elsewhere we have already checked
                         // that the base type is a class or interface type (and not, for example, an anonymous object type).
-                        let constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments);
+                        const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments);
                         if (forEach(constructors, sig => getReturnTypeOfSignature(sig) !== baseType)) {
                             error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type);
                         }
@@ -12979,17 +12985,17 @@ namespace ts {
                 }
             }
 
-            let implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
+            const implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
-                for (let typeRefNode of implementedTypeNodes) {
+                for (const typeRefNode of implementedTypeNodes) {
                     if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
                         error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
                     checkTypeReferenceNode(typeRefNode);
                     if (produceDiagnostics) {
-                        let t = getTypeFromTypeNode(typeRefNode);
+                        const t = getTypeFromTypeNode(typeRefNode);
                         if (t !== unknownType) {
-                            let declaredType = (t.flags & TypeFlags.Reference) ? (<TypeReference>t).target : t;
+                            const declaredType = (t.flags & TypeFlags.Reference) ? (<TypeReference>t).target : t;
                             if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) {
                                 checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(t, type.thisType), node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1);
                             }
@@ -13034,16 +13040,16 @@ namespace ts {
             // derived class instance member variables and accessors, but not by other kinds of members.
 
             // NOTE: assignability is checked in checkClassDeclaration
-            let baseProperties = getPropertiesOfObjectType(baseType);
-            for (let baseProperty of baseProperties) {
-                let base = getTargetSymbol(baseProperty);
+            const baseProperties = getPropertiesOfObjectType(baseType);
+            for (const baseProperty of baseProperties) {
+                const base = getTargetSymbol(baseProperty);
 
                 if (base.flags & SymbolFlags.Prototype) {
                     continue;
                 }
 
-                let derived = getTargetSymbol(getPropertyOfObjectType(type, base.name));
-                let baseDeclarationFlags = getDeclarationFlagsFromSymbol(base);
+                const derived = getTargetSymbol(getPropertyOfObjectType(type, base.name));
+                const baseDeclarationFlags = getDeclarationFlagsFromSymbol(base);
 
                 Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
 
@@ -13054,7 +13060,7 @@ namespace ts {
                     if (derived === base) {
                         // derived class inherits base without override/redeclaration
 
-                        let derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
+                        const derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
 
                         // It is an error to inherit an abstract member without implementing it or being declared abstract.
                         // If there is no declaration for the derived class (as in the case of class expressions),
@@ -13072,7 +13078,7 @@ namespace ts {
                     }
                     else {
                         // derived overrides base.
-                        let derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
+                        const derivedDeclarationFlags = getDeclarationFlagsFromSymbol(derived);
                         if ((baseDeclarationFlags & NodeFlags.Private) || (derivedDeclarationFlags & NodeFlags.Private)) {
                             // either base or derived property is private - not override, skip it
                             continue;
@@ -13129,8 +13135,8 @@ namespace ts {
             // When a generic interface has multiple declarations,  all declarations must have identical type parameter
             // lists, i.e. identical type parameter names with identical constraints in identical order.
             for (let i = 0, len = list1.length; i < len; i++) {
-                let tp1 = list1[i];
-                let tp2 = list2[i];
+                const tp1 = list1[i];
+                const tp2 = list2[i];
                 if (tp1.name.text !== tp2.name.text) {
                     return false;
                 }
@@ -13148,29 +13154,29 @@ namespace ts {
         }
 
         function checkInheritedPropertiesAreIdentical(type: InterfaceType, typeNode: Node): boolean {
-            let baseTypes = getBaseTypes(type);
+            const baseTypes = getBaseTypes(type);
             if (baseTypes.length < 2) {
                 return true;
             }
 
-            let seen: Map<{ prop: Symbol; containingType: Type }> = {};
+            const seen: Map<{ prop: Symbol; containingType: Type }> = {};
             forEach(resolveDeclaredMembers(type).declaredProperties, p => { seen[p.name] = { prop: p, containingType: type }; });
             let ok = true;
 
-            for (let base of baseTypes) {
-                let properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
-                for (let prop of properties) {
+            for (const base of baseTypes) {
+                const properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
+                for (const prop of properties) {
                     if (!hasProperty(seen, prop.name)) {
                         seen[prop.name] = { prop: prop, containingType: base };
                     }
                     else {
-                        let existing = seen[prop.name];
-                        let isInheritedProperty = existing.containingType !== type;
+                        const existing = seen[prop.name];
+                        const isInheritedProperty = existing.containingType !== type;
                         if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
                             ok = false;
 
-                            let typeName1 = typeToString(existing.containingType);
-                            let typeName2 = typeToString(base);
+                            const typeName1 = typeToString(existing.containingType);
+                            const typeName2 = typeToString(base);
 
                             let errorInfo = chainDiagnosticMessages(undefined, Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2);
                             errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
@@ -13192,8 +13198,8 @@ namespace ts {
                 checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);
 
                 checkExportsOnMergedDeclarations(node);
-                let symbol = getSymbolOfNode(node);
-                let firstInterfaceDecl = <InterfaceDeclaration>getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration);
+                const symbol = getSymbolOfNode(node);
+                const firstInterfaceDecl = <InterfaceDeclaration>getDeclarationOfKind(symbol, SyntaxKind.InterfaceDeclaration);
                 if (symbol.declarations.length > 1) {
                     if (node !== firstInterfaceDecl && !areTypeParametersIdentical(firstInterfaceDecl.typeParameters, node.typeParameters)) {
                         error(node.name, Diagnostics.All_declarations_of_an_interface_must_have_identical_type_parameters);
@@ -13202,11 +13208,11 @@ namespace ts {
 
                 // Only check this symbol once
                 if (node === firstInterfaceDecl) {
-                    let type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
-                    let typeWithThis = getTypeWithThisArgument(type);
+                    const type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
+                    const typeWithThis = getTypeWithThisArgument(type);
                     // run subsequent checks only if first set succeeded
                     if (checkInheritedPropertiesAreIdentical(type, node.name)) {
-                        for (let baseType of getBaseTypes(type)) {
+                        for (const baseType of getBaseTypes(type)) {
                             checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1);
                         }
                         checkIndexConstraints(type);
@@ -13236,14 +13242,14 @@ namespace ts {
         }
 
         function computeEnumMemberValues(node: EnumDeclaration) {
-            let nodeLinks = getNodeLinks(node);
+            const nodeLinks = getNodeLinks(node);
 
             if (!(nodeLinks.flags & NodeCheckFlags.EnumValuesComputed)) {
-                let enumSymbol = getSymbolOfNode(node);
-                let enumType = getDeclaredTypeOfSymbol(enumSymbol);
+                const enumSymbol = getSymbolOfNode(node);
+                const enumType = getDeclaredTypeOfSymbol(enumSymbol);
                 let autoValue = 0; // set to undefined when enum member is non-constant
-                let ambient = isInAmbientContext(node);
-                let enumIsConst = isConst(node);
+                const ambient = isInAmbientContext(node);
+                const enumIsConst = isConst(node);
 
                 for (const member of node.members) {
                     if (member.name.kind === SyntaxKind.ComputedPropertyName) {
@@ -13255,7 +13261,7 @@ namespace ts {
 
                     const previousEnumMemberIsNonConstant = autoValue === undefined;
 
-                    let initializer = member.initializer;
+                    const initializer = member.initializer;
                     if (initializer) {
                         autoValue = computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient);
                     }
@@ -13284,7 +13290,7 @@ namespace ts {
                 // Controls if error should be reported after evaluation of constant value is completed
                 // Can be false if another more precise error was already reported during evaluation.
                 let reportError = true;
-                let value = evalConstant(initializer);
+                const value = evalConstant(initializer);
 
                 if (reportError) {
                     if (value === undefined) {
@@ -13314,7 +13320,7 @@ namespace ts {
                 function evalConstant(e: Node): number {
                     switch (e.kind) {
                         case SyntaxKind.PrefixUnaryExpression:
-                            let value = evalConstant((<PrefixUnaryExpression>e).operand);
+                            const value = evalConstant((<PrefixUnaryExpression>e).operand);
                             if (value === undefined) {
                                 return undefined;
                             }
@@ -13325,11 +13331,11 @@ namespace ts {
                             }
                             return undefined;
                         case SyntaxKind.BinaryExpression:
-                            let left = evalConstant((<BinaryExpression>e).left);
+                            const left = evalConstant((<BinaryExpression>e).left);
                             if (left === undefined) {
                                 return undefined;
                             }
-                            let right = evalConstant((<BinaryExpression>e).right);
+                            const right = evalConstant((<BinaryExpression>e).right);
                             if (right === undefined) {
                                 return undefined;
                             }
@@ -13354,8 +13360,8 @@ namespace ts {
                         case SyntaxKind.Identifier:
                         case SyntaxKind.ElementAccessExpression:
                         case SyntaxKind.PropertyAccessExpression:
-                            let member = initializer.parent;
-                            let currentType = getTypeOfSymbol(getSymbolOfNode(member.parent));
+                            const member = initializer.parent;
+                            const currentType = getTypeOfSymbol(getSymbolOfNode(member.parent));
                             let enumType: Type;
                             let propertyName: string;
 
@@ -13405,12 +13411,12 @@ namespace ts {
                                 return undefined;
                             }
 
-                            let property = getPropertyOfObjectType(enumType, propertyName);
+                            const property = getPropertyOfObjectType(enumType, propertyName);
                             if (!property || !(property.flags & SymbolFlags.EnumMember)) {
                                 return undefined;
                             }
 
-                            let propertyDecl = property.valueDeclaration;
+                            const propertyDecl = property.valueDeclaration;
                             // self references are illegal
                             if (member === propertyDecl) {
                                 return undefined;
@@ -13444,7 +13450,7 @@ namespace ts {
 
             computeEnumMemberValues(node);
 
-            let enumIsConst = isConst(node);
+            const enumIsConst = isConst(node);
             if (compilerOptions.isolatedModules && enumIsConst && isInAmbientContext(node)) {
                 error(node.name, Diagnostics.Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided);
             }
@@ -13455,8 +13461,8 @@ namespace ts {
             // for the first member.
             //
             // Only perform this check once per symbol
-            let enumSymbol = getSymbolOfNode(node);
-            let firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
+            const enumSymbol = getSymbolOfNode(node);
+            const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
             if (node === firstDeclaration) {
                 if (enumSymbol.declarations.length > 1) {
                     // check that const is placed\omitted on all enum declarations
@@ -13474,12 +13480,12 @@ namespace ts {
                         return false;
                     }
 
-                    let enumDeclaration = <EnumDeclaration>declaration;
+                    const enumDeclaration = <EnumDeclaration>declaration;
                     if (!enumDeclaration.members.length) {
                         return false;
                     }
 
-                    let firstEnumMember = enumDeclaration.members[0];
+                    const firstEnumMember = enumDeclaration.members[0];
                     if (!firstEnumMember.initializer) {
                         if (seenEnumMissingInitialInitializer) {
                             error(firstEnumMember.name, Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
@@ -13493,8 +13499,8 @@ namespace ts {
         }
 
         function getFirstNonAmbientClassOrFunctionDeclaration(symbol: Symbol): Declaration {
-            let declarations = symbol.declarations;
-            for (let declaration of declarations) {
+            const declarations = symbol.declarations;
+            for (const declaration of declarations) {
                 if ((declaration.kind === SyntaxKind.ClassDeclaration ||
                     (declaration.kind === SyntaxKind.FunctionDeclaration && nodeIsPresent((<FunctionLikeDeclaration>declaration).body))) &&
                     !isInAmbientContext(declaration)) {
@@ -13505,8 +13511,8 @@ namespace ts {
         }
 
         function inSameLexicalScope(node1: Node, node2: Node) {
-            let container1 = getEnclosingBlockScopeContainer(node1);
-            let container2 = getEnclosingBlockScopeContainer(node2);
+            const container1 = getEnclosingBlockScopeContainer(node1);
+            const container2 = getEnclosingBlockScopeContainer(node2);
             if (isGlobalSourceFile(container1)) {
                 return isGlobalSourceFile(container2);
             }
@@ -13521,8 +13527,8 @@ namespace ts {
         function checkModuleDeclaration(node: ModuleDeclaration) {
             if (produceDiagnostics) {
                 // Grammar checking
-                let isAmbientExternalModule = node.name.kind === SyntaxKind.StringLiteral;
-                let contextErrorMessage = isAmbientExternalModule
+                const isAmbientExternalModule = node.name.kind === SyntaxKind.StringLiteral;
+                const contextErrorMessage = isAmbientExternalModule
                     ? Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file
                     : Diagnostics.A_namespace_declaration_is_only_allowed_in_a_namespace_or_module;
                 if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
@@ -13539,14 +13545,14 @@ namespace ts {
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
                 checkExportsOnMergedDeclarations(node);
-                let symbol = getSymbolOfNode(node);
+                const symbol = getSymbolOfNode(node);
 
                 // The following checks only apply on a non-ambient instantiated module declaration.
                 if (symbol.flags & SymbolFlags.ValueModule
                     && symbol.declarations.length > 1
                     && !isInAmbientContext(node)
                     && isInstantiatedModule(node, compilerOptions.preserveConstEnums || compilerOptions.isolatedModules)) {
-                    let firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
+                    const firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
                     if (firstNonAmbientClassOrFunc) {
                         if (getSourceFileOfNode(node) !== getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
                             error(node.name, Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged);
@@ -13558,7 +13564,7 @@ namespace ts {
 
                     // if the module merges with a class declaration in the same lexical scope,
                     // we need to track this to ensure the correct emit.
-                    let mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);
+                    const mergedClass = getDeclarationOfKind(symbol, SyntaxKind.ClassDeclaration);
                     if (mergedClass &&
                         inSameLexicalScope(node, mergedClass)) {
                         getNodeLinks(node).flags |= NodeCheckFlags.LexicalModuleMergesWithClass;
@@ -13595,12 +13601,12 @@ namespace ts {
         }
 
         function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
-            let moduleName = getExternalModuleName(node);
+            const moduleName = getExternalModuleName(node);
             if (!nodeIsMissing(moduleName) && moduleName.kind !== SyntaxKind.StringLiteral) {
                 error(moduleName, Diagnostics.String_literal_expected);
                 return false;
             }
-            let inAmbientExternalModule = node.parent.kind === SyntaxKind.ModuleBlock && (<ModuleDeclaration>node.parent.parent).name.kind === SyntaxKind.StringLiteral;
+            const inAmbientExternalModule = node.parent.kind === SyntaxKind.ModuleBlock && (<ModuleDeclaration>node.parent.parent).name.kind === SyntaxKind.StringLiteral;
             if (node.parent.kind !== SyntaxKind.SourceFile && !inAmbientExternalModule) {
                 error(moduleName, node.kind === SyntaxKind.ExportDeclaration ?
                     Diagnostics.Export_declarations_are_not_permitted_in_a_namespace :
@@ -13619,15 +13625,15 @@ namespace ts {
         }
 
         function checkAliasSymbol(node: ImportEqualsDeclaration | ImportClause | NamespaceImport | ImportSpecifier | ExportSpecifier) {
-            let symbol = getSymbolOfNode(node);
-            let target = resolveAlias(symbol);
+            const symbol = getSymbolOfNode(node);
+            const target = resolveAlias(symbol);
             if (target !== unknownSymbol) {
-                let excludedMeanings =
+                const excludedMeanings =
                     (symbol.flags & SymbolFlags.Value ? SymbolFlags.Value : 0) |
                     (symbol.flags & SymbolFlags.Type ? SymbolFlags.Type : 0) |
                     (symbol.flags & SymbolFlags.Namespace ? SymbolFlags.Namespace : 0);
                 if (target.flags & excludedMeanings) {
-                    let message = node.kind === SyntaxKind.ExportSpecifier ?
+                    const message = node.kind === SyntaxKind.ExportSpecifier ?
                         Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 :
                         Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
                     error(node, message, symbolToString(symbol));
@@ -13650,7 +13656,7 @@ namespace ts {
                 grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers);
             }
             if (checkExternalImportOrExportDeclaration(node)) {
-                let importClause = node.importClause;
+                const importClause = node.importClause;
                 if (importClause) {
                     if (importClause.name) {
                         checkImportBinding(importClause);
@@ -13680,11 +13686,11 @@ namespace ts {
                     markExportAsReferenced(node);
                 }
                 if (isInternalModuleImportEqualsDeclaration(node)) {
-                    let target = resolveAlias(getSymbolOfNode(node));
+                    const target = resolveAlias(getSymbolOfNode(node));
                     if (target !== unknownSymbol) {
                         if (target.flags & SymbolFlags.Value) {
                             // Target is a value symbol, check that it is not hidden by a local declaration with the same name
-                            let moduleName = getFirstIdentifier(<EntityName>node.moduleReference);
+                            const moduleName = getFirstIdentifier(<EntityName>node.moduleReference);
                             if (!(resolveEntityName(moduleName, SymbolFlags.Value | SymbolFlags.Namespace).flags & SymbolFlags.Namespace)) {
                                 error(moduleName, Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, declarationNameToString(moduleName));
                             }
@@ -13719,14 +13725,14 @@ namespace ts {
                     // export { x, y } from "foo"
                     forEach(node.exportClause.elements, checkExportSpecifier);
 
-                    let inAmbientExternalModule = node.parent.kind === SyntaxKind.ModuleBlock && (<ModuleDeclaration>node.parent.parent).name.kind === SyntaxKind.StringLiteral;
+                    const inAmbientExternalModule = node.parent.kind === SyntaxKind.ModuleBlock && (<ModuleDeclaration>node.parent.parent).name.kind === SyntaxKind.StringLiteral;
                     if (node.parent.kind !== SyntaxKind.SourceFile && !inAmbientExternalModule) {
                         error(node, Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
                     }
                 }
                 else {
                     // export * from "foo"
-                    let moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
+                    const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
                     if (moduleSymbol && moduleSymbol.exports["export="]) {
                         error(node.moduleSpecifier, Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol));
                     }
@@ -13753,7 +13759,7 @@ namespace ts {
                 return;
             }
 
-            let container = node.parent.kind === SyntaxKind.SourceFile ? <SourceFile>node.parent : <ModuleDeclaration>node.parent.parent;
+            const container = node.parent.kind === SyntaxKind.SourceFile ? <SourceFile>node.parent : <ModuleDeclaration>node.parent.parent;
             if (container.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>container).name.kind === SyntaxKind.Identifier) {
                 error(node, Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
                 return;
@@ -13803,12 +13809,12 @@ namespace ts {
         }
 
         function checkExternalModuleExports(node: SourceFile | ModuleDeclaration) {
-            let moduleSymbol = getSymbolOfNode(node);
-            let links = getSymbolLinks(moduleSymbol);
+            const moduleSymbol = getSymbolOfNode(node);
+            const links = getSymbolLinks(moduleSymbol);
             if (!links.exportsChecked) {
-                let exportEqualsSymbol = moduleSymbol.exports["export="];
+                const exportEqualsSymbol = moduleSymbol.exports["export="];
                 if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
-                    let declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
+                    const declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
                     error(declaration, Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
                 }
                 links.exportsChecked = true;
@@ -13826,7 +13832,7 @@ namespace ts {
                 return;
             }
 
-            let kind = node.kind;
+            const kind = node.kind;
             if (cancellationToken) {
                 // Only bother checking on a few construct kinds.  We don't want to be excessivly
                 // hitting the cancellation token on every node we check.
@@ -13950,8 +13956,8 @@ namespace ts {
 
         // Function and class expression bodies are checked after all statements in the enclosing body. This is
         // to ensure constructs like the following are permitted:
-        //     let foo = function () {
-        //        let s = foo();
+        //     const foo = function () {
+        //        const s = foo();
         //        return "hello";
         //     }
         // Here, performing a full type check of the body of the function expression whilst in the process of
@@ -14057,7 +14063,7 @@ namespace ts {
         }
 
         function checkSourceFile(node: SourceFile) {
-            let start = new Date().getTime();
+            const start = new Date().getTime();
 
             checkSourceFileWorker(node);
 
@@ -14066,7 +14072,7 @@ namespace ts {
 
         // Fully type check a source file and collect the relevant diagnostics.
         function checkSourceFileWorker(node: SourceFile) {
-            let links = getNodeLinks(node);
+            const links = getNodeLinks(node);
             if (!(links.flags & NodeCheckFlags.TypeChecked)) {
                 // Check whether the file has declared it is the default lib,
                 // and whether the user has specifically chosen to avoid checking it.
@@ -14168,7 +14174,7 @@ namespace ts {
         }
 
         function getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[] {
-            let symbols: SymbolTable = {};
+            const symbols: SymbolTable = {};
             let memberFlags: NodeFlags = 0;
 
             if (isInsideWithStatementBody(location)) {
@@ -14198,7 +14204,7 @@ namespace ts {
                             copySymbols(getSymbolOfNode(location).exports, meaning & SymbolFlags.EnumMember);
                             break;
                         case SyntaxKind.ClassExpression:
-                            let className = (<ClassExpression>location).name;
+                            const className = (<ClassExpression>location).name;
                             if (className) {
                                 copySymbol(location.symbol, meaning);
                             }
@@ -14215,7 +14221,7 @@ namespace ts {
                             }
                             break;
                         case SyntaxKind.FunctionExpression:
-                            let funcName = (<FunctionExpression>location).name;
+                            const funcName = (<FunctionExpression>location).name;
                             if (funcName) {
                                 copySymbol(location.symbol, meaning);
                             }
@@ -14242,7 +14248,7 @@ namespace ts {
              */
             function copySymbol(symbol: Symbol, meaning: SymbolFlags): void {
                 if (symbol.flags & meaning) {
-                    let id = symbol.name;
+                    const id = symbol.name;
                     // We will copy all symbol regardless of its reserved name because
                     // symbolsToArray will check whether the key is a reserved name and
                     // it will not copy symbol with reserved name to the array
@@ -14254,8 +14260,8 @@ namespace ts {
 
             function copySymbols(source: SymbolTable, meaning: SymbolFlags): void {
                 if (meaning) {
-                    for (let id in source) {
-                        let symbol = source[id];
+                    for (const id in source) {
+                        const symbol = source[id];
                         copySymbol(symbol, meaning);
                     }
                 }
@@ -14372,18 +14378,18 @@ namespace ts {
                 if (entityName.kind === SyntaxKind.Identifier) {
                     // Include aliases in the meaning, this ensures that we do not follow aliases to where they point and instead
                     // return the alias symbol.
-                    let meaning: SymbolFlags = SymbolFlags.Value | SymbolFlags.Alias;
+                    const meaning: SymbolFlags = SymbolFlags.Value | SymbolFlags.Alias;
                     return resolveEntityName(<Identifier>entityName, meaning);
                 }
                 else if (entityName.kind === SyntaxKind.PropertyAccessExpression) {
-                    let symbol = getNodeLinks(entityName).resolvedSymbol;
+                    const symbol = getNodeLinks(entityName).resolvedSymbol;
                     if (!symbol) {
                         checkPropertyAccessExpression(<PropertyAccessExpression>entityName);
                     }
                     return getNodeLinks(entityName).resolvedSymbol;
                 }
                 else if (entityName.kind === SyntaxKind.QualifiedName) {
-                    let symbol = getNodeLinks(entityName).resolvedSymbol;
+                    const symbol = getNodeLinks(entityName).resolvedSymbol;
                     if (!symbol) {
                         checkQualifiedName(<QualifiedName>entityName);
                     }
@@ -14429,8 +14435,8 @@ namespace ts {
                 else if (node.parent.kind === SyntaxKind.BindingElement &&
                         node.parent.parent.kind === SyntaxKind.ObjectBindingPattern &&
                         node === (<BindingElement>node.parent).propertyName) {
-                    let typeOfPattern = getTypeOfNode(node.parent.parent);
-                    let propertyDeclaration = typeOfPattern && getPropertyOfType(typeOfPattern, (<Identifier>node).text);
+                    const typeOfPattern = getTypeOfNode(node.parent.parent);
+                    const propertyDeclaration = typeOfPattern && getPropertyOfType(typeOfPattern, (<Identifier>node).text);
 
                     if (propertyDeclaration) {
                         return propertyDeclaration;
@@ -14446,12 +14452,12 @@ namespace ts {
 
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.SuperKeyword:
-                    let type = isExpression(node) ? checkExpression(<Expression>node) : getTypeFromTypeNode(<TypeNode>node);
+                    const type = isExpression(node) ? checkExpression(<Expression>node) : getTypeFromTypeNode(<TypeNode>node);
                     return type.symbol;
 
                 case SyntaxKind.ConstructorKeyword:
                     // constructor keyword for an overload, should take us to the definition if it exist
-                    let constructorDeclaration = node.parent;
+                    const constructorDeclaration = node.parent;
                     if (constructorDeclaration && constructorDeclaration.kind === SyntaxKind.Constructor) {
                         return (<ClassDeclaration>constructorDeclaration.parent).symbol;
                     }
@@ -14470,9 +14476,9 @@ namespace ts {
                 case SyntaxKind.NumericLiteral:
                     // index access
                     if (node.parent.kind === SyntaxKind.ElementAccessExpression && (<ElementAccessExpression>node.parent).argumentExpression === node) {
-                        let objectType = checkExpression((<ElementAccessExpression>node.parent).expression);
+                        const objectType = checkExpression((<ElementAccessExpression>node.parent).expression);
                         if (objectType === unknownType) return undefined;
-                        let apparentType = getApparentType(objectType);
+                        const apparentType = getApparentType(objectType);
                         if (apparentType === unknownType) return undefined;
                         return getPropertyOfType(apparentType, (<LiteralExpression>node).text);
                     }
@@ -14513,23 +14519,23 @@ namespace ts {
 
             if (isTypeDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
-                let symbol = getSymbolOfNode(node);
+                const symbol = getSymbolOfNode(node);
                 return getDeclaredTypeOfSymbol(symbol);
             }
 
             if (isTypeDeclarationName(node)) {
-                let symbol = getSymbolAtLocation(node);
+                const symbol = getSymbolAtLocation(node);
                 return symbol && getDeclaredTypeOfSymbol(symbol);
             }
 
             if (isDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
-                let symbol = getSymbolOfNode(node);
+                const symbol = getSymbolOfNode(node);
                 return getTypeOfSymbol(symbol);
             }
 
             if (isDeclarationName(node)) {
-                let symbol = getSymbolAtLocation(node);
+                const symbol = getSymbolAtLocation(node);
                 return symbol && getTypeOfSymbol(symbol);
             }
 
@@ -14538,8 +14544,8 @@ namespace ts {
             }
 
             if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
-                let symbol = getSymbolAtLocation(node);
-                let declaredType = symbol && getDeclaredTypeOfSymbol(symbol);
+                const symbol = getSymbolAtLocation(node);
+                const declaredType = symbol && getDeclaredTypeOfSymbol(symbol);
                 return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
             }
 
@@ -14559,7 +14565,7 @@ namespace ts {
           * whether the element is declared as "static".
           */
         function getParentTypeOfClassElement(node: ClassElement) {
-            let classSymbol = getSymbolOfNode(node.parent);
+            const classSymbol = getSymbolOfNode(node.parent);
             return node.flags & NodeFlags.Static
                 ? getTypeOfSymbol(classSymbol)
                 : getDeclaredTypeOfSymbol(classSymbol);
@@ -14569,7 +14575,7 @@ namespace ts {
         // if the type has call or construct signatures
         function getAugmentedPropertiesOfType(type: Type): Symbol[] {
             type = getApparentType(type);
-            let propsByName = createSymbolTable(getPropertiesOfType(type));
+            const propsByName = createSymbolTable(getPropertiesOfType(type));
             if (getSignaturesOfType(type, SignatureKind.Call).length || getSignaturesOfType(type, SignatureKind.Construct).length) {
                 forEach(getPropertiesOfType(globalFunctionType), p => {
                     if (!hasProperty(propsByName, p.name)) {
@@ -14582,10 +14588,10 @@ namespace ts {
 
         function getRootSymbols(symbol: Symbol): Symbol[] {
             if (symbol.flags & SymbolFlags.SyntheticProperty) {
-                let symbols: Symbol[] = [];
-                let name = symbol.name;
+                const symbols: Symbol[] = [];
+                const name = symbol.name;
                 forEach(getSymbolLinks(symbol).containingType.types, t => {
-                    let symbol = getPropertyOfType(t, name);
+                    const symbol = getPropertyOfType(t, name);
                     if (symbol) {
                         symbols.push(symbol);
                     }
@@ -14593,7 +14599,7 @@ namespace ts {
                 return symbols;
             }
             else if (symbol.flags & SymbolFlags.Transient) {
-                let target = getSymbolLinks(symbol).target;
+                const target = getSymbolLinks(symbol).target;
                 if (target) {
                     return [target];
                 }
@@ -14616,13 +14622,13 @@ namespace ts {
                     // If we reference an exported entity within the same module declaration, then whether
                     // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the
                     // kinds that we do NOT prefix.
-                    let exportSymbol = getMergedSymbol(symbol.exportSymbol);
+                    const exportSymbol = getMergedSymbol(symbol.exportSymbol);
                     if (exportSymbol.flags & SymbolFlags.ExportHasLocal) {
                         return undefined;
                     }
                     symbol = exportSymbol;
                 }
-                let parentSymbol = getParentOfSymbol(symbol);
+                const parentSymbol = getParentOfSymbol(symbol);
                 if (parentSymbol) {
                     if (parentSymbol.flags & SymbolFlags.ValueModule && parentSymbol.valueDeclaration.kind === SyntaxKind.SourceFile) {
                         return <SourceFile>parentSymbol.valueDeclaration;
@@ -14639,7 +14645,7 @@ namespace ts {
         // When resolved as an expression identifier, if the given node references an import, return the declaration of
         // that import. Otherwise, return undefined.
         function getReferencedImportDeclaration(node: Identifier): Declaration {
-            let symbol = getReferencedValueSymbol(node);
+            const symbol = getReferencedValueSymbol(node);
             return symbol && symbol.flags & SymbolFlags.Alias ? getDeclarationOfAliasSymbol(symbol) : undefined;
         }
 
@@ -14657,9 +14663,9 @@ namespace ts {
 
         function isNestedRedeclarationSymbol(symbol: Symbol): boolean {
             if (symbol.flags & SymbolFlags.BlockScoped) {
-                let links = getSymbolLinks(symbol);
+                const links = getSymbolLinks(symbol);
                 if (links.isNestedRedeclaration === undefined) {
-                    let container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
+                    const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
                     links.isNestedRedeclaration = isStatementWithLocals(container) &&
                     !!resolveName(container.parent, symbol.name, SymbolFlags.Value, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
                 }
@@ -14671,7 +14677,7 @@ namespace ts {
         // When resolved as an expression identifier, if the given node references a nested block scoped entity with
         // a name that hides an existing name, return the declaration of that entity. Otherwise, return undefined.
         function getReferencedNestedRedeclaration(node: Identifier): Declaration {
-            let symbol = getReferencedValueSymbol(node);
+            const symbol = getReferencedValueSymbol(node);
             return symbol && isNestedRedeclarationSymbol(symbol) ? symbol.valueDeclaration : undefined;
         }
 
@@ -14690,7 +14696,7 @@ namespace ts {
                 case SyntaxKind.ExportSpecifier:
                     return isAliasResolvedToValue(getSymbolOfNode(node));
                 case SyntaxKind.ExportDeclaration:
-                    let exportClause = (<ExportDeclaration>node).exportClause;
+                    const exportClause = (<ExportDeclaration>node).exportClause;
                     return exportClause && forEach(exportClause.elements, isValueAliasDeclaration);
                 case SyntaxKind.ExportAssignment:
                     return (<ExportAssignment>node).expression && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier ? isAliasResolvedToValue(getSymbolOfNode(node)) : true;
@@ -14704,12 +14710,12 @@ namespace ts {
                 return false;
             }
 
-            let isValue = isAliasResolvedToValue(getSymbolOfNode(node));
+            const isValue = isAliasResolvedToValue(getSymbolOfNode(node));
             return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
         }
 
         function isAliasResolvedToValue(symbol: Symbol): boolean {
-            let target = resolveAlias(symbol);
+            const target = resolveAlias(symbol);
             if (target === unknownSymbol && compilerOptions.isolatedModules) {
                 return true;
             }
@@ -14727,7 +14733,7 @@ namespace ts {
 
         function isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean {
             if (isAliasSymbolDeclaration(node)) {
-                let symbol = getSymbolOfNode(node);
+                const symbol = getSymbolOfNode(node);
                 if (getSymbolLinks(symbol).referenced) {
                     return true;
                 }
@@ -14741,8 +14747,8 @@ namespace ts {
 
         function isImplementationOfOverload(node: FunctionLikeDeclaration) {
             if (nodeIsPresent(node.body)) {
-                let symbol = getSymbolOfNode(node);
-                let signaturesOfSymbol = getSignaturesOfSymbol(symbol);
+                const symbol = getSymbolOfNode(node);
+                const signaturesOfSymbol = getSignaturesOfSymbol(symbol);
                 // If this function body corresponds to function with multiple signature, it is implementation of overload
                 // e.g.: function foo(a: string): string;
                 //       function foo(a: number): number;
@@ -14774,7 +14780,7 @@ namespace ts {
                 return getEnumMemberValue(<EnumMember>node);
             }
 
-            let symbol = getNodeLinks(node).resolvedSymbol;
+            const symbol = getNodeLinks(node).resolvedSymbol;
             if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
                 // inline property\index accesses only for const enums
                 if (isConstEnumDeclaration(symbol.valueDeclaration.parent)) {
@@ -14791,19 +14797,19 @@ namespace ts {
 
         function getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind {
             // Resolve the symbol as a value to ensure the type can be reached at runtime during emit.
-            let valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true);
-            let constructorType = valueSymbol ? getTypeOfSymbol(valueSymbol) : undefined;
+            const valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true);
+            const constructorType = valueSymbol ? getTypeOfSymbol(valueSymbol) : undefined;
             if (constructorType && isConstructorType(constructorType)) {
                 return TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue;
             }
 
             // Resolve the symbol as a type so that we can provide a more useful hint for the type serializer.
-            let typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true);
+            const typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true);
             // We might not be able to resolve type symbol so use unknown type in that case (eg error case)
             if (!typeSymbol) {
                 return TypeReferenceSerializationKind.ObjectType;
             }
-            let type = getDeclaredTypeOfSymbol(typeSymbol);
+            const type = getDeclaredTypeOfSymbol(typeSymbol);
             if (type === unknownType) {
                 return TypeReferenceSerializationKind.Unknown;
             }
@@ -14841,8 +14847,8 @@ namespace ts {
 
         function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
             // Get type of the symbol if this is the valid symbol otherwise get type at location
-            let symbol = getSymbolOfNode(declaration);
-            let type = symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))
+            const symbol = getSymbolOfNode(declaration);
+            const type = symbol && !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.Signature))
                 ? getTypeOfSymbol(symbol)
                 : unknownType;
 
@@ -14850,12 +14856,12 @@ namespace ts {
         }
 
         function writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
-            let signature = getSignatureFromDeclaration(signatureDeclaration);
+            const signature = getSignatureFromDeclaration(signatureDeclaration);
             getSymbolDisplayBuilder().buildTypeDisplay(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags);
         }
 
         function writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
-            let type = getTypeOfExpression(expr);
+            const type = getTypeOfExpression(expr);
             getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
         }
 
@@ -14871,7 +14877,7 @@ namespace ts {
 
         function getReferencedValueDeclaration(reference: Identifier): Declaration {
             Debug.assert(!nodeIsSynthesized(reference));
-            let symbol = getReferencedValueSymbol(reference);
+            const symbol = getReferencedValueSymbol(reference);
             return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
         }
 
@@ -14880,12 +14886,12 @@ namespace ts {
                 return unknownType;
             }
 
-            let signature = getSingleCallSignature(functionType);
+            const signature = getSingleCallSignature(functionType);
             if (!signature) {
                 return unknownType;
             }
 
-            let instantiatedSignature = getSignatureInstantiation(signature, typeArguments);
+            const instantiatedSignature = getSignatureInstantiation(signature, typeArguments);
             return getOrCreateTypeFromSignature(instantiatedSignature);
         }
 
@@ -14919,7 +14925,7 @@ namespace ts {
         function initializeTypeChecker() {
             // Bind all source files and propagate errors
             forEach(host.getSourceFiles(), file => {
-                bindSourceFile(file);
+                bindSourceFile(file, compilerOptions);
             });
 
             // Initialize global symbol table
@@ -14983,7 +14989,7 @@ namespace ts {
         }
 
         function createInstantiatedPromiseLikeType(): ObjectType {
-            let promiseLikeType = getGlobalPromiseLikeType();
+            const promiseLikeType = getGlobalPromiseLikeType();
             if (promiseLikeType !== emptyGenericType) {
                 return createTypeReference(<GenericType>promiseLikeType, [anyType]);
             }
@@ -14993,10 +14999,10 @@ namespace ts {
 
         function createThenableType() {
             // build the thenable type that is used to verify against a non-promise "thenable" operand to `await`.
-            let thenPropertySymbol = createSymbol(SymbolFlags.Transient | SymbolFlags.Property, "then");
+            const thenPropertySymbol = createSymbol(SymbolFlags.Transient | SymbolFlags.Property, "then");
             getSymbolLinks(thenPropertySymbol).type = globalFunctionType;
 
-            let thenableType = <ResolvedType>createObjectType(TypeFlags.Anonymous);
+            const thenableType = <ResolvedType>createObjectType(TypeFlags.Anonymous);
             thenableType.properties = [thenPropertySymbol];
             thenableType.members = createSymbolTable(thenableType.properties);
             thenableType.callSignatures = [];
@@ -15013,7 +15019,7 @@ namespace ts {
                 return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
             }
             else if (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor) {
-                let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, <AccessorDeclaration>node);
+                const accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, <AccessorDeclaration>node);
                 if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) {
                     return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
                 }
@@ -15068,7 +15074,7 @@ namespace ts {
 
             let lastStatic: Node, lastPrivate: Node, lastProtected: Node, lastDeclare: Node, lastAsync: Node;
             let flags = 0;
-            for (let modifier of node.modifiers) {
+            for (const modifier of node.modifiers) {
                 switch (modifier.kind) {
                     case SyntaxKind.PublicKeyword:
                     case SyntaxKind.ProtectedKeyword:
@@ -15259,9 +15265,9 @@ namespace ts {
 
         function checkGrammarForDisallowedTrailingComma(list: NodeArray<Node>): boolean {
             if (list && list.hasTrailingComma) {
-                let start = list.end - ",".length;
-                let end = list.end;
-                let sourceFile = getSourceFileOfNode(list[0]);
+                const start = list.end - ",".length;
+                const end = list.end;
+                const sourceFile = getSourceFileOfNode(list[0]);
                 return grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Trailing_comma_not_allowed);
             }
         }
@@ -15272,8 +15278,8 @@ namespace ts {
             }
 
             if (typeParameters && typeParameters.length === 0) {
-                let start = typeParameters.pos - "<".length;
-                let end = skipTrivia(file.text, typeParameters.end) + ">".length;
+                const start = typeParameters.pos - "<".length;
+                const end = skipTrivia(file.text, typeParameters.end) + ">".length;
                 return grammarErrorAtPos(file, start, end - start, Diagnostics.Type_parameter_list_cannot_be_empty);
             }
         }
@@ -15284,10 +15290,10 @@ namespace ts {
             }
 
             let seenOptionalParameter = false;
-            let parameterCount = parameters.length;
+            const parameterCount = parameters.length;
 
             for (let i = 0; i < parameterCount; i++) {
-                let parameter = parameters[i];
+                const parameter = parameters[i];
                 if (parameter.dotDotDotToken) {
                     if (i !== (parameterCount - 1)) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
@@ -15320,16 +15326,16 @@ namespace ts {
 
         function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean {
             // Prevent cascading error by short-circuit
-            let file = getSourceFileOfNode(node);
+            const file = getSourceFileOfNode(node);
             return checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarTypeParameterList(node, node.typeParameters, file) ||
                 checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file);
         }
 
         function checkGrammarArrowFunction(node: FunctionLikeDeclaration, file: SourceFile): boolean {
             if (node.kind === SyntaxKind.ArrowFunction) {
-                let arrowFunction = <ArrowFunction>node;
-                let startLine = getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line;
-                let endLine = getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line;
+                const arrowFunction = <ArrowFunction>node;
+                const startLine = getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.pos).line;
+                const endLine = getLineAndCharacterOfPosition(file, arrowFunction.equalsGreaterThanToken.end).line;
                 if (startLine !== endLine) {
                     return grammarErrorOnNode(arrowFunction.equalsGreaterThanToken, Diagnostics.Line_terminator_not_permitted_before_arrow);
                 }
@@ -15338,7 +15344,7 @@ namespace ts {
         }
 
         function checkGrammarIndexSignatureParameters(node: SignatureDeclaration): boolean {
-            let parameter = node.parameters[0];
+            const parameter = node.parameters[0];
             if (node.parameters.length !== 1) {
                 if (parameter) {
                     return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
@@ -15383,9 +15389,9 @@ namespace ts {
 
         function checkGrammarForAtLeastOneTypeArgument(node: Node, typeArguments: NodeArray<TypeNode>): boolean {
             if (typeArguments && typeArguments.length === 0) {
-                let sourceFile = getSourceFileOfNode(node);
-                let start = typeArguments.pos - "<".length;
-                let end = skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
+                const sourceFile = getSourceFileOfNode(node);
+                const start = typeArguments.pos - "<".length;
+                const end = skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
                 return grammarErrorAtPos(sourceFile, start, end - start, Diagnostics.Type_argument_list_cannot_be_empty);
             }
         }
@@ -15397,8 +15403,8 @@ namespace ts {
 
         function checkGrammarForOmittedArgument(node: CallExpression, args: NodeArray<Expression>): boolean {
             if (args) {
-                let sourceFile = getSourceFileOfNode(node);
-                for (let arg of args) {
+                const sourceFile = getSourceFileOfNode(node);
+                for (const arg of args) {
                     if (arg.kind === SyntaxKind.OmittedExpression) {
                         return grammarErrorAtPos(sourceFile, arg.pos, 0, Diagnostics.Argument_expression_expected);
                     }
@@ -15412,13 +15418,13 @@ namespace ts {
         }
 
         function checkGrammarHeritageClause(node: HeritageClause): boolean {
-            let types = node.types;
+            const types = node.types;
             if (checkGrammarForDisallowedTrailingComma(types)) {
                 return true;
             }
             if (types && types.length === 0) {
-                let listType = tokenToString(node.token);
-                let sourceFile = getSourceFileOfNode(node);
+                const listType = tokenToString(node.token);
+                const sourceFile = getSourceFileOfNode(node);
                 return grammarErrorAtPos(sourceFile, types.pos, 0, Diagnostics._0_list_cannot_be_empty, listType);
             }
         }
@@ -15428,7 +15434,7 @@ namespace ts {
             let seenImplementsClause = false;
 
             if (!checkGrammarDecorators(node) && !checkGrammarModifiers(node) && node.heritageClauses) {
-                for (let heritageClause of node.heritageClauses) {
+                for (const heritageClause of node.heritageClauses) {
                     if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
                         if (seenExtendsClause) {
                             return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
@@ -15463,7 +15469,7 @@ namespace ts {
             let seenExtendsClause = false;
 
             if (node.heritageClauses) {
-                for (let heritageClause of node.heritageClauses) {
+                for (const heritageClause of node.heritageClauses) {
                     if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
                         if (seenExtendsClause) {
                             return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
@@ -15490,7 +15496,7 @@ namespace ts {
                 return false;
             }
 
-            let computedPropertyName = <ComputedPropertyName>node;
+            const computedPropertyName = <ComputedPropertyName>node;
             if (computedPropertyName.expression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>computedPropertyName.expression).operatorToken.kind === SyntaxKind.CommaToken) {
                 return grammarErrorOnNode(computedPropertyName.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
             }
@@ -15521,14 +15527,14 @@ namespace ts {
         }
 
         function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) {
-            let seen: Map<SymbolFlags> = {};
-            let Property = 1;
-            let GetAccessor = 2;
-            let SetAccesor = 4;
-            let GetOrSetAccessor = GetAccessor | SetAccesor;
+            const seen: Map<SymbolFlags> = {};
+            const Property = 1;
+            const GetAccessor = 2;
+            const SetAccesor = 4;
+            const GetOrSetAccessor = GetAccessor | SetAccesor;
 
-            for (let prop of node.properties) {
-                let name = prop.name;
+            for (const prop of node.properties) {
+                const name = prop.name;
                 if (prop.kind === SyntaxKind.OmittedExpression ||
                     name.kind === SyntaxKind.ComputedPropertyName) {
                     // If the name is not a ComputedPropertyName, the grammar checking will skip it
@@ -15576,7 +15582,7 @@ namespace ts {
                     seen[(<Identifier>name).text] = currentKind;
                 }
                 else {
-                    let existingKind = seen[(<Identifier>name).text];
+                    const existingKind = seen[(<Identifier>name).text];
                     if (currentKind === Property && existingKind === Property) {
                         continue;
                     }
@@ -15597,13 +15603,13 @@ namespace ts {
 
         function checkGrammarJsxElement(node: JsxOpeningLikeElement) {
             const seen: Map<boolean> = {};
-            for (let attr of node.attributes) {
+            for (const attr of node.attributes) {
                 if (attr.kind === SyntaxKind.JsxSpreadAttribute) {
                     continue;
                 }
 
-                let jsxAttr = (<JsxAttribute>attr);
-                let name = jsxAttr.name;
+                const jsxAttr = (<JsxAttribute>attr);
+                const name = jsxAttr.name;
                 if (!hasProperty(seen, name.text)) {
                     seen[name.text] = true;
                 }
@@ -15611,7 +15617,7 @@ namespace ts {
                     return grammarErrorOnNode(name, Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
                 }
 
-                let initializer = jsxAttr.initializer;
+                const initializer = jsxAttr.initializer;
                 if (initializer && initializer.kind === SyntaxKind.JsxExpression && !(<JsxExpression>initializer).expression) {
                     return grammarErrorOnNode(jsxAttr.initializer, Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression);
                 }
@@ -15624,23 +15630,23 @@ namespace ts {
             }
 
             if (forInOrOfStatement.initializer.kind === SyntaxKind.VariableDeclarationList) {
-                let variableList = <VariableDeclarationList>forInOrOfStatement.initializer;
+                const variableList = <VariableDeclarationList>forInOrOfStatement.initializer;
                 if (!checkGrammarVariableDeclarationList(variableList)) {
                     if (variableList.declarations.length > 1) {
-                        let diagnostic = forInOrOfStatement.kind === SyntaxKind.ForInStatement
+                        const diagnostic = forInOrOfStatement.kind === SyntaxKind.ForInStatement
                             ? Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement
                             : Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement;
                         return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic);
                     }
-                    let firstDeclaration = variableList.declarations[0];
+                    const firstDeclaration = variableList.declarations[0];
                     if (firstDeclaration.initializer) {
-                        let diagnostic = forInOrOfStatement.kind === SyntaxKind.ForInStatement
+                        const diagnostic = forInOrOfStatement.kind === SyntaxKind.ForInStatement
                             ? Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer
                             : Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer;
                         return grammarErrorOnNode(firstDeclaration.name, diagnostic);
                     }
                     if (firstDeclaration.type) {
-                        let diagnostic = forInOrOfStatement.kind === SyntaxKind.ForInStatement
+                        const diagnostic = forInOrOfStatement.kind === SyntaxKind.ForInStatement
                             ? Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation
                             : Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation;
                         return grammarErrorOnNode(firstDeclaration, diagnostic);
@@ -15652,7 +15658,7 @@ namespace ts {
         }
 
         function checkGrammarAccessor(accessor: MethodDeclaration): boolean {
-            let kind = accessor.kind;
+            const kind = accessor.kind;
             if (languageVersion < ScriptTarget.ES5) {
                 return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
             }
@@ -15676,7 +15682,7 @@ namespace ts {
                     return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
                 }
                 else {
-                    let parameter = accessor.parameters[0];
+                    const parameter = accessor.parameters[0];
                     if (parameter.dotDotDotToken) {
                         return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_set_accessor_cannot_have_rest_parameter);
                     }
@@ -15751,7 +15757,7 @@ namespace ts {
                         if (node.label && (<LabeledStatement>current).label.text === node.label.text) {
                             // found matching label - verify that label usage is correct
                             // continue can only target labels that are on iteration statements
-                            let isMisplacedContinueLabel = node.kind === SyntaxKind.ContinueStatement
+                            const isMisplacedContinueLabel = node.kind === SyntaxKind.ContinueStatement
                                 && !isIterationStatement((<LabeledStatement>current).statement, /*lookInLabeledStatement*/ true);
 
                             if (isMisplacedContinueLabel) {
@@ -15779,14 +15785,14 @@ namespace ts {
             }
 
             if (node.label) {
-                let message = node.kind === SyntaxKind.BreakStatement
+                const message = node.kind === SyntaxKind.BreakStatement
                     ? Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement
                     : Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
 
                 return grammarErrorOnNode(node, message);
             }
             else {
-                let message = node.kind === SyntaxKind.BreakStatement
+                const message = node.kind === SyntaxKind.BreakStatement
                     ? Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement
                     : Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
                 return grammarErrorOnNode(node, message);
@@ -15795,7 +15801,7 @@ namespace ts {
 
         function checkGrammarBindingElement(node: BindingElement) {
             if (node.dotDotDotToken) {
-                let elements = (<BindingPattern>node.parent).elements;
+                const elements = (<BindingPattern>node.parent).elements;
                 if (node !== lastOrUndefined(elements)) {
                     return grammarErrorOnNode(node, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                 }
@@ -15816,7 +15822,7 @@ namespace ts {
                 if (isInAmbientContext(node)) {
                     if (node.initializer) {
                         // Error on equals token which immediate precedes the initializer
-                        let equalsTokenLength = "=".length;
+                        const equalsTokenLength = "=".length;
                         return grammarErrorAtPos(getSourceFileOfNode(node), node.initializer.pos - equalsTokenLength,
                             equalsTokenLength, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
                     }
@@ -15831,7 +15837,7 @@ namespace ts {
                 }
             }
 
-            let checkLetConstNames = languageVersion >= ScriptTarget.ES6 && (isLet(node) || isConst(node));
+            const checkLetConstNames = languageVersion >= ScriptTarget.ES6 && (isLet(node) || isConst(node));
 
             // 1. LexicalDeclaration : LetOrConst BindingList ;
             // It is a Syntax Error if the BoundNames of BindingList contains "let".
@@ -15850,8 +15856,8 @@ namespace ts {
                 }
             }
             else {
-                let elements = (<BindingPattern>name).elements;
-                for (let element of elements) {
+                const elements = (<BindingPattern>name).elements;
+                for (const element of elements) {
                     if (element.kind !== SyntaxKind.OmittedExpression) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
@@ -15860,7 +15866,7 @@ namespace ts {
         }
 
         function checkGrammarVariableDeclarationList(declarationList: VariableDeclarationList): boolean {
-            let declarations = declarationList.declarations;
+            const declarations = declarationList.declarations;
             if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) {
                 return true;
             }
@@ -15900,7 +15906,7 @@ namespace ts {
 
         function isIntegerLiteral(expression: Expression): boolean {
             if (expression.kind === SyntaxKind.PrefixUnaryExpression) {
-                let unaryExpression = <PrefixUnaryExpression>expression;
+                const unaryExpression = <PrefixUnaryExpression>expression;
                 if (unaryExpression.operator === SyntaxKind.PlusToken || unaryExpression.operator === SyntaxKind.MinusToken) {
                     expression = unaryExpression.operand;
                 }
@@ -15922,9 +15928,9 @@ namespace ts {
         }
 
         function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            let sourceFile = getSourceFileOfNode(node);
+            const sourceFile = getSourceFileOfNode(node);
             if (!hasParseDiagnostics(sourceFile)) {
-                let span = getSpanOfTokenAtPosition(sourceFile, node.pos);
+                const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
                 diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
                 return true;
             }
@@ -15938,7 +15944,7 @@ namespace ts {
         }
 
         function grammarErrorOnNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            let sourceFile = getSourceFileOfNode(node);
+            const sourceFile = getSourceFileOfNode(node);
             if (!hasParseDiagnostics(sourceFile)) {
                 diagnostics.add(createDiagnosticForNode(node, message, arg0, arg1, arg2));
                 return true;
@@ -16014,7 +16020,7 @@ namespace ts {
         }
 
         function checkGrammarTopLevelElementsForRequiredDeclareModifier(file: SourceFile): boolean {
-            for (let decl of file.statements) {
+            for (const decl of file.statements) {
                 if (isDeclaration(decl) || decl.kind === SyntaxKind.VariableStatement) {
                     if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
                         return true;
@@ -16035,7 +16041,7 @@ namespace ts {
                 }
 
                 // Find containing block which is either Block, ModuleBlock, SourceFile
-                let links = getNodeLinks(node);
+                const links = getNodeLinks(node);
                 if (!links.hasReportedStatementInAmbientContext && isFunctionLike(node.parent)) {
                     return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
                 }
@@ -16046,7 +16052,7 @@ namespace ts {
                 // this has already been reported, and don't report if it has.
                 //
                 if (node.parent.kind === SyntaxKind.Block || node.parent.kind === SyntaxKind.ModuleBlock || node.parent.kind === SyntaxKind.SourceFile) {
-                    let links = getNodeLinks(node.parent);
+                    const links = getNodeLinks(node.parent);
                     // Check if the containing block ever report this error
                     if (!links.hasReportedStatementInAmbientContext) {
                         return links.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
@@ -16068,9 +16074,9 @@ namespace ts {
         }
 
         function grammarErrorAfterFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): boolean {
-            let sourceFile = getSourceFileOfNode(node);
+            const sourceFile = getSourceFileOfNode(node);
             if (!hasParseDiagnostics(sourceFile)) {
-                let span = getSpanOfTokenAtPosition(sourceFile, node.pos);
+                const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
                 diagnostics.add(createFileDiagnostic(sourceFile, textSpanEnd(span), /*length*/ 0, message, arg0, arg1, arg2));
                 return true;
             }
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index a89687a4390..3c3bb14174d 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -1,6 +1,7 @@
 /// <reference path="sys.ts"/>
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
+/// <reference path="diagnosticInformationMap.generated.ts"/>
 /// <reference path="scanner.ts"/>
 
 namespace ts {
@@ -150,6 +151,12 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
         },
+        {
+            name: "pretty",
+            paramType: Diagnostics.KIND,
+            description: Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
         {
             name: "project",
             shortName: "p",
@@ -248,6 +255,26 @@ namespace ts {
             description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
             error: Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic,
         },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
         {
             name: "forceConsistentCasingInFileNames",
             type: "boolean",
@@ -273,8 +300,8 @@ namespace ts {
             return optionNameMapCache;
         }
 
-        let optionNameMap: Map<CommandLineOption> = {};
-        let shortOptionNames: Map<string> = {};
+        const optionNameMap: Map<CommandLineOption> = {};
+        const shortOptionNames: Map<string> = {};
         forEach(optionDeclarations, option => {
             optionNameMap[option.name.toLowerCase()] = option;
             if (option.shortName) {
@@ -287,10 +314,10 @@ namespace ts {
     }
 
     export function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine {
-        let options: CompilerOptions = {};
-        let fileNames: string[] = [];
-        let errors: Diagnostic[] = [];
-        let { optionNameMap, shortOptionNames } = getOptionNameMap();
+        const options: CompilerOptions = {};
+        const fileNames: string[] = [];
+        const errors: Diagnostic[] = [];
+        const { optionNameMap, shortOptionNames } = getOptionNameMap();
 
         parseStrings(commandLine);
         return {
@@ -315,7 +342,7 @@ namespace ts {
                     }
 
                     if (hasProperty(optionNameMap, s)) {
-                        let opt = optionNameMap[s];
+                        const opt = optionNameMap[s];
 
                         // Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).
                         if (!args[i] && opt.type !== "boolean") {
@@ -355,19 +382,19 @@ namespace ts {
         }
 
         function parseResponseFile(fileName: string) {
-            let text = readFile ? readFile(fileName) : sys.readFile(fileName);
+            const text = readFile ? readFile(fileName) : sys.readFile(fileName);
 
             if (!text) {
                 errors.push(createCompilerDiagnostic(Diagnostics.File_0_not_found, fileName));
                 return;
             }
 
-            let args: string[] = [];
+            const args: string[] = [];
             let pos = 0;
             while (true) {
                 while (pos < text.length && text.charCodeAt(pos) <= CharacterCodes.space) pos++;
                 if (pos >= text.length) break;
-                let start = pos;
+                const start = pos;
                 if (text.charCodeAt(start) === CharacterCodes.doubleQuote) {
                     pos++;
                     while (pos < text.length && text.charCodeAt(pos) !== CharacterCodes.doubleQuote) pos++;
@@ -410,13 +437,41 @@ namespace ts {
       */
     export function parseConfigFileTextToJson(fileName: string, jsonText: string): { config?: any; error?: Diagnostic } {
         try {
-            return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
+            const jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
         }
         catch (e) {
             return { error: createCompilerDiagnostic(Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
         }
     }
 
+
+    /**
+     * Remove the comments from a json like text.
+     * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
+     *
+     * This method replace comment content by whitespace rather than completely remove them to keep positions in json parsing error reporting accurate.
+     */
+    function removeComments(jsonText: string): string {
+        let output = "";
+        const scanner = createScanner(ScriptTarget.ES5, /* skipTrivia */ false, LanguageVariant.Standard, jsonText);
+        let token: SyntaxKind;
+        while ((token = scanner.scan()) !== SyntaxKind.EndOfFileToken) {
+            switch (token) {
+                case SyntaxKind.SingleLineCommentTrivia:
+                case SyntaxKind.MultiLineCommentTrivia:
+                    // replace comments with whitespace to preserve original character positions
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
+
+
     /**
       * Parse the contents of a config file (tsconfig.json).
       * @param json The contents of the config file to parse
@@ -425,9 +480,9 @@ namespace ts {
       *    file to. e.g. outDir
       */
     export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions: CompilerOptions = {}): ParsedCommandLine {
-        let { options, errors } = convertCompilerOptionsFromJson(json["compilerOptions"], basePath);
+        const { options: optionsFromJsonConfigFile, errors } = convertCompilerOptionsFromJson(json["compilerOptions"], basePath);
 
-        options = extend(existingOptions, options);
+        const options = extend(existingOptions, optionsFromJsonConfigFile);
         return {
             options,
             fileNames: getFileNames(),
@@ -445,20 +500,20 @@ namespace ts {
                 }
             }
             else {
-                let filesSeen: Map<boolean> = {};
-                let exclude = json["exclude"] instanceof Array ? map(<string[]>json["exclude"], normalizeSlashes) : undefined;
-                let extensionsByPriority = getSupportedExtensions(options);
+                const filesSeen: Map<boolean> = {};
+                const exclude = json["exclude"] instanceof Array ? map(<string[]>json["exclude"], normalizeSlashes) : undefined;
+                const extensionsByPriority = getSupportedExtensions(options);
                 for (let extensionsIndex = 0; extensionsIndex < extensionsByPriority.length; extensionsIndex++) {
-                    let currentExtension = extensionsByPriority[extensionsIndex];
-                    let filesInDirWithExtension = host.readDirectory(basePath, currentExtension, exclude);
+                    const currentExtension = extensionsByPriority[extensionsIndex];
+                    const filesInDirWithExtension = host.readDirectory(basePath, currentExtension, exclude);
                     // Get list of conflicting extensions, conflicting extension is
                     // - extension that is lower priority than current extension and 
                     // - extension also is current extension (ends with "." + currentExtension)
-                    let conflictingExtensions: string[] = [];
+                    const conflictingExtensions: string[] = [];
                     for (let i = extensionsIndex + 1; i < extensionsByPriority.length; i++) {
-                        let extension = extensionsByPriority[i]; // lower priority extension
+                        const extension = extensionsByPriority[i]; // lower priority extension
                         if (fileExtensionIs(extension, currentExtension)) { // also has current extension
-                            conflictingExtensions.push(extension);
+                            conflictingExtensions.push(extension);
                         }
                     }
 
@@ -490,24 +545,24 @@ namespace ts {
     }
 
     export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string): { options: CompilerOptions, errors: Diagnostic[] } {
-        let options: CompilerOptions = {};
-        let errors: Diagnostic[] = [];
+        const options: CompilerOptions = {};
+        const errors: Diagnostic[] = [];
 
         if (!jsonOptions) {
             return { options, errors };
         }
 
-        let optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);
+        const optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);
 
-        for (let id in jsonOptions) {
+        for (const id in jsonOptions) {
             if (hasProperty(optionNameMap, id)) {
-                let opt = optionNameMap[id];
-                let optType = opt.type;
+                const opt = optionNameMap[id];
+                const optType = opt.type;
                 let value = jsonOptions[id];
-                let expectedType = typeof optType === "string" ? optType : "string";
+                const expectedType = typeof optType === "string" ? optType : "string";
                 if (typeof value === expectedType) {
                     if (typeof optType !== "string") {
-                        let key = value.toLowerCase();
+                        const key = value.toLowerCase();
                         if (hasProperty(optType, key)) {
                             value = optType[key];
                         }
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 1b19eb5a77b..5b0eedfc1f9 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -29,7 +29,7 @@ namespace ts {
         };
 
         function forEachValueInMap(f: (key: Path, value: T) => void) {
-            for (let key in files) {
+            for (const key in files) {
                 f(<Path>key, files[key]);
             }
         }
@@ -84,7 +84,7 @@ namespace ts {
     export function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
         if (array) {
             for (let i = 0, len = array.length; i < len; i++) {
-                let result = callback(array[i], i);
+                const result = callback(array[i], i);
                 if (result) {
                     return result;
                 }
@@ -95,7 +95,7 @@ namespace ts {
 
     export function contains<T>(array: T[], value: T): boolean {
         if (array) {
-            for (let v of array) {
+            for (const v of array) {
                 if (v === value) {
                     return true;
                 }
@@ -118,7 +118,7 @@ namespace ts {
     export function countWhere<T>(array: T[], predicate: (x: T) => boolean): number {
         let count = 0;
         if (array) {
-            for (let v of array) {
+            for (const v of array) {
                 if (predicate(v)) {
                     count++;
                 }
@@ -131,7 +131,7 @@ namespace ts {
         let result: T[];
         if (array) {
             result = [];
-            for (let item of array) {
+            for (const item of array) {
                 if (f(item)) {
                     result.push(item);
                 }
@@ -144,7 +144,7 @@ namespace ts {
         let result: U[];
         if (array) {
             result = [];
-            for (let v of array) {
+            for (const v of array) {
                 result.push(f(v));
             }
         }
@@ -162,7 +162,7 @@ namespace ts {
         let result: T[];
         if (array) {
             result = [];
-            for (let item of array) {
+            for (const item of array) {
                 if (!contains(result, item)) {
                     result.push(item);
                 }
@@ -173,7 +173,7 @@ namespace ts {
 
     export function sum(array: any[], prop: string): number {
         let result = 0;
-        for (let v of array) {
+        for (const v of array) {
             result += v[prop];
         }
         return result;
@@ -181,7 +181,7 @@ namespace ts {
 
     export function addRange<T>(to: T[], from: T[]): void {
         if (to && from) {
-            for (let v of from) {
+            for (const v of from) {
                 to.push(v);
             }
         }
@@ -220,8 +220,8 @@ namespace ts {
         let high = array.length - 1;
 
         while (low <= high) {
-            let middle = low + ((high - low) >> 1);
-            let midValue = array[middle];
+            const middle = low + ((high - low) >> 1);
+            const midValue = array[middle];
 
             if (midValue === value) {
                 return middle;
@@ -270,7 +270,7 @@ namespace ts {
         return initial;
     }
 
-    let hasOwnProperty = Object.prototype.hasOwnProperty;
+    const hasOwnProperty = Object.prototype.hasOwnProperty;
 
     export function hasProperty<T>(map: Map<T>, key: string): boolean {
         return hasOwnProperty.call(map, key);
@@ -281,7 +281,7 @@ namespace ts {
     }
 
     export function isEmpty<T>(map: Map<T>) {
-        for (let id in map) {
+        for (const id in map) {
             if (hasProperty(map, id)) {
                 return false;
             }
@@ -290,19 +290,19 @@ namespace ts {
     }
 
     export function clone<T>(object: T): T {
-        let result: any = {};
-        for (let id in object) {
+        const result: any = {};
+        for (const id in object) {
             result[id] = (<any>object)[id];
         }
         return <T>result;
     }
 
     export function extend<T1, T2>(first: Map<T1>, second: Map<T2>): Map<T1 & T2> {
-        let result: Map<T1 & T2> = {};
-        for (let id in first) {
+        const result: Map<T1 & T2> = {};
+        for (const id in first) {
             (result as any)[id] = first[id];
         }
-        for (let id in second) {
+        for (const id in second) {
             if (!hasProperty(result, id)) {
                 (result as any)[id] = second[id];
             }
@@ -312,7 +312,7 @@ namespace ts {
 
     export function forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U {
         let result: U;
-        for (let id in map) {
+        for (const id in map) {
             if (result = callback(map[id])) break;
         }
         return result;
@@ -320,7 +320,7 @@ namespace ts {
 
     export function forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U {
         let result: U;
-        for (let id in map) {
+        for (const id in map) {
             if (result = callback(id)) break;
         }
         return result;
@@ -331,7 +331,7 @@ namespace ts {
     }
 
     export function copyMap<T>(source: Map<T>, target: Map<T>): void {
-        for (let p in source) {
+        for (const p in source) {
             target[p] = source[p];
         }
     }
@@ -347,7 +347,7 @@ namespace ts {
      * index in the array will be the one associated with the produced key.
      */
     export function arrayToMap<T>(array: T[], makeKey: (value: T) => string): Map<T> {
-        let result: Map<T> = {};
+        const result: Map<T> = {};
 
         forEach(array, value => {
             result[makeKey(value)] = value;
@@ -383,7 +383,7 @@ namespace ts {
 
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ...args: any[]): Diagnostic;
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage): Diagnostic {
-        let end = start + length;
+        const end = start + length;
 
         Debug.assert(start >= 0, "start must be non-negative, is " + start);
         Debug.assert(length >= 0, "length must be non-negative, is " + length);
@@ -479,10 +479,10 @@ namespace ts {
     function compareMessageText(text1: string | DiagnosticMessageChain, text2: string | DiagnosticMessageChain): Comparison {
         while (text1 && text2) {
             // We still have both chains.
-            let string1 = typeof text1 === "string" ? text1 : text1.messageText;
-            let string2 = typeof text2 === "string" ? text2 : text2.messageText;
+            const string1 = typeof text1 === "string" ? text1 : text1.messageText;
+            const string2 = typeof text2 === "string" ? text2 : text2.messageText;
 
-            let res = compareValues(string1, string2);
+            const res = compareValues(string1, string2);
             if (res) {
                 return res;
             }
@@ -509,11 +509,11 @@ namespace ts {
             return diagnostics;
         }
 
-        let newDiagnostics = [diagnostics[0]];
+        const newDiagnostics = [diagnostics[0]];
         let previousDiagnostic = diagnostics[0];
         for (let i = 1; i < diagnostics.length; i++) {
-            let currentDiagnostic = diagnostics[i];
-            let isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === Comparison.EqualTo;
+            const currentDiagnostic = diagnostics[i];
+            const isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === Comparison.EqualTo;
             if (!isDupe) {
                 newDiagnostics.push(currentDiagnostic);
                 previousDiagnostic = currentDiagnostic;
@@ -531,9 +531,9 @@ namespace ts {
     export function getRootLength(path: string): number {
         if (path.charCodeAt(0) === CharacterCodes.slash) {
             if (path.charCodeAt(1) !== CharacterCodes.slash) return 1;
-            let p1 = path.indexOf("/", 2);
+            const p1 = path.indexOf("/", 2);
             if (p1 < 0) return 2;
-            let p2 = path.indexOf("/", p1 + 1);
+            const p2 = path.indexOf("/", p1 + 1);
             if (p2 < 0) return p1 + 1;
             return p2 + 1;
         }
@@ -549,7 +549,7 @@ namespace ts {
         if (path.lastIndexOf("file:///", 0) === 0) {
             return "file:///".length;
         }
-        let idx = path.indexOf("://");
+        const idx = path.indexOf("://");
         if (idx !== -1) {
             return idx + "://".length;
         }
@@ -558,9 +558,9 @@ namespace ts {
 
     export let directorySeparator = "/";
     function getNormalizedParts(normalizedSlashedPath: string, rootLength: number) {
-        let parts = normalizedSlashedPath.substr(rootLength).split(directorySeparator);
-        let normalized: string[] = [];
-        for (let part of parts) {
+        const parts = normalizedSlashedPath.substr(rootLength).split(directorySeparator);
+        const normalized: string[] = [];
+        for (const part of parts) {
             if (part !== ".") {
                 if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
@@ -580,8 +580,8 @@ namespace ts {
 
     export function normalizePath(path: string): string {
         path = normalizeSlashes(path);
-        let rootLength = getRootLength(path);
-        let normalized = getNormalizedParts(path, rootLength);
+        const rootLength = getRootLength(path);
+        const normalized = getNormalizedParts(path, rootLength);
         return path.substr(0, rootLength) + normalized.join(directorySeparator);
     }
 
@@ -598,7 +598,7 @@ namespace ts {
     }
 
     function normalizedPathComponents(path: string, rootLength: number) {
-        let normalizedParts = getNormalizedParts(path, rootLength);
+        const normalizedParts = getNormalizedParts(path, rootLength);
         return [path.substr(0, rootLength)].concat(normalizedParts);
     }
 
@@ -629,7 +629,7 @@ namespace ts {
         // In this example the root is:  http://www.website.com/
         // normalized path components should be ["http://www.website.com/", "folder1", "folder2"]
 
-        let urlLength = url.length;
+        const urlLength = url.length;
         // Initial root length is http:// part
         let rootLength = url.indexOf("://") + "://".length;
         while (rootLength < urlLength) {
@@ -650,7 +650,7 @@ namespace ts {
         }
 
         // Find the index of "/" after website.com so the root can be http://www.website.com/ (from existing http://)
-        let indexOfNextSlash = url.indexOf(directorySeparator, rootLength);
+        const indexOfNextSlash = url.indexOf(directorySeparator, rootLength);
         if (indexOfNextSlash !== -1) {
             // Found the "/" after the website.com so the root is length of http://www.website.com/
             // and get components afetr the root normally like any other folder components
@@ -676,8 +676,8 @@ namespace ts {
     }
 
     export function getRelativePathToDirectoryOrUrl(directoryPathOrUrl: string, relativeOrAbsolutePath: string, currentDirectory: string, getCanonicalFileName: (fileName: string) => string, isAbsolutePathAnUrl: boolean) {
-        let pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
-        let directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
+        const pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
+        const directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
         if (directoryComponents.length > 1 && lastOrUndefined(directoryComponents) === "") {
             // If the directory path given was of type test/cases/ then we really need components of directory to be only till its name
             // that is  ["test", "cases", ""] needs to be actually ["test", "cases"]
@@ -694,7 +694,7 @@ namespace ts {
         // Get the relative path
         if (joinStartIndex) {
             let relativePath = "";
-            let relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length);
+            const relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length);
             for (; joinStartIndex < directoryComponents.length; joinStartIndex++) {
                 if (directoryComponents[joinStartIndex] !== "") {
                     relativePath = relativePath + ".." + directorySeparator;
@@ -717,7 +717,7 @@ namespace ts {
         if (path === undefined) {
             return undefined;
         }
-        let i = path.lastIndexOf(directorySeparator);
+        const i = path.lastIndexOf(directorySeparator);
         return i < 0 ? path : path.substring(i + 1);
     }
 
@@ -730,8 +730,8 @@ namespace ts {
     }
 
     export function fileExtensionIs(path: string, extension: string): boolean {
-        let pathLen = path.length;
-        let extLen = extension.length;
+        const pathLen = path.length;
+        const extLen = extension.length;
         return pathLen > extLen && path.substr(pathLen - extLen, extLen) === extension;
     }
 
@@ -749,7 +749,7 @@ namespace ts {
     export function isSupportedSourceFileName(fileName: string, compilerOptions?: CompilerOptions) {
         if (!fileName) { return false; }
 
-        for (let extension of getSupportedExtensions(compilerOptions)) {
+        for (const extension of getSupportedExtensions(compilerOptions)) {
             if (fileExtensionIs(fileName, extension)) {
                 return true;
             }
@@ -759,7 +759,7 @@ namespace ts {
 
     const extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     export function removeFileExtension(path: string): string {
-        for (let ext of extensionsToRemove) {
+        for (const ext of extensionsToRemove) {
             if (fileExtensionIs(path, ext)) {
                 return path.substr(0, path.length - ext.length);
             }
@@ -767,9 +767,9 @@ namespace ts {
         return path;
     }
 
-    let backslashOrDoubleQuote = /[\"\\]/g;
-    let escapedCharsRegExp = /[\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    let escapedCharsMap: Map<string> = {
+    const backslashOrDoubleQuote = /[\"\\]/g;
+    const escapedCharsRegExp = /[\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
+    const escapedCharsMap: Map<string> = {
         "\0": "\\0",
         "\t": "\\t",
         "\v": "\\v",
@@ -828,7 +828,7 @@ namespace ts {
     }
 
     export namespace Debug {
-        let currentAssertionLevel = AssertionLevel.None;
+        const currentAssertionLevel = AssertionLevel.None;
 
         export function shouldAssert(level: AssertionLevel): boolean {
             return currentAssertionLevel >= level;
@@ -851,8 +851,8 @@ namespace ts {
     }
 
     export function copyListRemovingItem<T>(item: T, list: T[]) {
-        let copiedList: T[] = [];
-        for (let e of list) {
+        const copiedList: T[] = [];
+        for (const e of list) {
             if (e !== item) {
                 copiedList.push(e);
             }
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 348a22e23e8..c965a5a3911 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -31,7 +31,7 @@ namespace ts {
     }
 
     export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
-        let declarationDiagnostics = createDiagnosticCollection();
+        const declarationDiagnostics = createDiagnosticCollection();
         forEachExpectedEmitFile(host, getDeclarationDiagnosticsFromFile, targetSourceFile);
         return declarationDiagnostics.getDiagnostics(targetSourceFile.fileName);
 
@@ -42,8 +42,8 @@ namespace ts {
 
     function emitDeclarations(host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, declarationFilePath: string,
         sourceFiles: SourceFile[], isBundledEmit: boolean): DeclarationEmit {
-        let newLine = host.getNewLine();
-        let compilerOptions = host.getCompilerOptions();
+        const newLine = host.getNewLine();
+        const compilerOptions = host.getCompilerOptions();
 
         let write: (s: string) => void;
         let writeLine: () => void;
@@ -57,10 +57,10 @@ namespace ts {
         let currentSourceFile: SourceFile;
         let reportedDeclarationError = false;
         let errorNameNode: DeclarationName;
-        let emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
-        let emit = compilerOptions.stripInternal ? stripInternal : emitNode;
+        const emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
+        const emit = compilerOptions.stripInternal ? stripInternal : emitNode;
 
-        let moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
+        const moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
         let asynchronousSubModuleDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];
 
         // Contains the reference paths that needs to go in the declaration file.
@@ -69,14 +69,14 @@ namespace ts {
         let referencePathsOutput = "";
 
         // Emit references corresponding to each file
-        let emittedReferencedFiles: SourceFile[] = [];
+        const emittedReferencedFiles: SourceFile[] = [];
         let addedGlobalFileReference = false;
         forEach(sourceFiles, sourceFile => {
             if (!isJavaScript(sourceFile.fileName)) {
                 // Check what references need to be added
                 if (!compilerOptions.noResolve) {
                     forEach(sourceFile.referencedFiles, fileReference => {
-                        let referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
+                        const referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
 
                         // Emit reference in dts, if the file reference was not already emitted
                         if (referencedFile && !contains(emittedReferencedFiles, referencedFile)) {
@@ -96,7 +96,7 @@ namespace ts {
 
                 // create asynchronous output for the importDeclarations
                 if (moduleElementDeclarationEmitInfo.length) {
-                    let oldWriter = writer;
+                    const oldWriter = writer;
                     forEach(moduleElementDeclarationEmitInfo, aliasEmitInfo => {
                         if (aliasEmitInfo.isVisible) {
                             Debug.assert(aliasEmitInfo.node.kind === SyntaxKind.ImportDeclaration);
@@ -119,14 +119,14 @@ namespace ts {
         };
 
         function hasInternalAnnotation(range: CommentRange) {
-            let text = currentSourceFile.text;
-            let comment = text.substring(range.pos, range.end);
+            const text = currentSourceFile.text;
+            const comment = text.substring(range.pos, range.end);
             return comment.indexOf("@internal") >= 0;
         }
 
         function stripInternal(node: Node) {
             if (node) {
-                let leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+                const leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
                 if (forEach(leadingCommentRanges, hasInternalAnnotation)) {
                     return;
                 }
@@ -136,7 +136,7 @@ namespace ts {
         }
 
         function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
-            let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
+            const writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
             writer.reportInaccessibleThisError = reportInaccessibleThisError;
             writer.writeKeyword = writer.write;
@@ -160,7 +160,7 @@ namespace ts {
         }
 
         function writeAsynchronousModuleElements(nodes: Node[]) {
-            let oldWriter = writer;
+            const oldWriter = writer;
             forEach(nodes, declaration => {
                 let nodeToCheck: Node;
                 if (declaration.kind === SyntaxKind.VariableDeclaration) {
@@ -223,7 +223,7 @@ namespace ts {
             else {
                 // Report error
                 reportedDeclarationError = true;
-                let errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult);
+                const errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult);
                 if (errorInfo) {
                     if (errorInfo.typeName) {
                         emitterDiagnostics.add(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
@@ -283,14 +283,14 @@ namespace ts {
         }
 
         function emitLines(nodes: Node[]) {
-            for (let node of nodes) {
+            for (const node of nodes) {
                 emit(node);
             }
         }
 
         function emitSeparatedList(nodes: Node[], separator: string, eachNodeEmitFn: (node: Node) => void, canEmitFn?: (node: Node) => boolean) {
             let currentWriterPos = writer.getTextPos();
-            for (let node of nodes) {
+            for (const node of nodes) {
                 if (!canEmitFn || canEmitFn(node)) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         write(separator);
@@ -307,7 +307,7 @@ namespace ts {
 
         function writeJsDocComments(declaration: Node) {
             if (declaration) {
-                let jsDocComments = getJsDocComments(declaration, currentSourceFile);
+                const jsDocComments = getJsDocComments(declaration, currentSourceFile);
                 emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments);
                 // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
                 emitComments(currentSourceFile, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
@@ -364,8 +364,8 @@ namespace ts {
                     writeTextOfNode(currentSourceFile, entityName);
                 }
                 else {
-                    let left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
-                    let right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
+                    const left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
+                    const right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
                     writeEntityName(left);
                     write(".");
                     writeTextOfNode(currentSourceFile, right);
@@ -373,7 +373,7 @@ namespace ts {
             }
 
             function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
-                let visibilityResult = resolver.isEntityNameVisible(entityName,
+                const visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
                     entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
 
@@ -454,6 +454,7 @@ namespace ts {
         function emitSourceFile(node: SourceFile) {
             currentSourceFile = node;
             enclosingDeclaration = node;
+            emitDetachedComments(currentSourceFile, writer, writeCommentRange, node, newLine, true /* remove comments */);
             emitLines(node.statements);
         }
 
@@ -462,13 +463,13 @@ namespace ts {
         // Note that export default is only allowed at most once in a module, so we
         // do not need to keep track of created temp names.
         function getExportDefaultTempVariableName(): string {
-            let baseName = "_default";
+            const baseName = "_default";
             if (!hasProperty(currentSourceFile.identifiers, baseName)) {
                 return baseName;
             }
             let count = 0;
             while (true) {
-                let name = baseName + "_" + (++count);
+                const name = baseName + "_" + (++count);
                 if (!hasProperty(currentSourceFile.identifiers, name)) {
                     return name;
                 }
@@ -482,7 +483,7 @@ namespace ts {
             }
             else {
                 // Expression
-                let tempVarName = getExportDefaultTempVariableName();
+                const tempVarName = getExportDefaultTempVariableName();
                 write("declare var ");
                 write(tempVarName);
                 write(": ");
@@ -498,7 +499,7 @@ namespace ts {
 
             // Make all the declarations visible for the export name
             if (node.expression.kind === SyntaxKind.Identifier) {
-                let nodes = resolver.collectLinkedAliases(<Identifier>node.expression);
+                const nodes = resolver.collectLinkedAliases(<Identifier>node.expression);
 
                 // write each of these declarations asynchronously
                 writeAsynchronousModuleElements(nodes);
@@ -535,7 +536,7 @@ namespace ts {
                 }
                 else {
                     if (node.kind === SyntaxKind.ImportDeclaration) {
-                        let importDeclaration = <ImportDeclaration>node;
+                        const importDeclaration = <ImportDeclaration>node;
                         if (importDeclaration.importClause) {
                             isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||
                             isVisibleNamedBinding(importDeclaration.importClause.namedBindings);
@@ -661,7 +662,7 @@ namespace ts {
             }
             write("import ");
             if (node.importClause) {
-                let currentWriterPos = writer.getTextPos();
+                const currentWriterPos = writer.getTextPos();
                 if (node.importClause.name && resolver.isDeclarationVisible(node.importClause)) {
                     writeTextOfNode(currentSourceFile, node.importClause.name);
                 }
@@ -699,7 +700,7 @@ namespace ts {
             emitImportOrExportSpecifier(node);
 
             // Make all the declarations visible for the export name
-            let nodes = resolver.collectLinkedAliases(node.propertyName || node.name);
+            const nodes = resolver.collectLinkedAliases(node.propertyName || node.name);
 
             // write each of these declarations asynchronously
             writeAsynchronousModuleElements(nodes);
@@ -739,7 +740,7 @@ namespace ts {
                 write(".");
                 writeTextOfNode(currentSourceFile, node.name);
             }
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             write(" {");
             writeLine();
@@ -752,7 +753,7 @@ namespace ts {
         }
 
         function writeTypeAliasDeclaration(node: TypeAliasDeclaration) {
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
@@ -794,7 +795,7 @@ namespace ts {
         function emitEnumMemberDeclaration(node: EnumMember) {
             emitJsDocComments(node);
             writeTextOfNode(currentSourceFile, node.name);
-            let enumMemberValue = resolver.getConstantValue(node);
+            const enumMemberValue = resolver.getConstantValue(node);
             if (enumMemberValue !== undefined) {
                 write(" = ");
                 write(enumMemberValue.toString());
@@ -944,10 +945,10 @@ namespace ts {
 
             write("class ");
             writeTextOfNode(currentSourceFile, node.name);
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitTypeParameters(node.typeParameters);
-            let baseTypeNode = getClassExtendsHeritageClauseElement(node);
+            const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
                 emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
             }
@@ -968,7 +969,7 @@ namespace ts {
             emitModuleElementDeclarationFlags(node);
             write("interface ");
             writeTextOfNode(currentSourceFile, node.name);
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitTypeParameters(node.typeParameters);
             emitHeritageClause(getInterfaceBaseTypeNodes(node), /*isImplementsList*/ false);
@@ -1054,7 +1055,7 @@ namespace ts {
             }
 
             function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                const diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                 return diagnosticMessage !== undefined ? {
                     diagnosticMessage,
                     errorNode: node,
@@ -1068,8 +1069,8 @@ namespace ts {
                 // For example:
                 //      original: var [, c,,] = [ 2,3,4]
                 //      emitted: declare var c: number; // instead of declare var c:number, ;
-                let elements: Node[] = [];
-                for (let element of bindingPattern.elements) {
+                const elements: Node[] = [];
+                for (const element of bindingPattern.elements) {
                     if (element.kind !== SyntaxKind.OmittedExpression) {
                         elements.push(element);
                     }
@@ -1079,7 +1080,7 @@ namespace ts {
 
             function emitBindingElement(bindingElement: BindingElement) {
                 function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                    const diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                     return diagnosticMessage !== undefined ? {
                         diagnosticMessage,
                         errorNode: bindingElement,
@@ -1135,7 +1136,7 @@ namespace ts {
                 return;
             }
 
-            let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
+            const accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
             let accessorWithTypeAnnotation: AccessorDeclaration;
 
             if (node === accessors.firstAccessor) {
@@ -1148,7 +1149,7 @@ namespace ts {
                     let type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
                         // couldn't get type for the first accessor, try the another one
-                        let anotherAccessor = node.kind === SyntaxKind.GetAccessor ? accessors.setAccessor : accessors.getAccessor;
+                        const anotherAccessor = node.kind === SyntaxKind.GetAccessor ? accessors.setAccessor : accessors.getAccessor;
                         type = getTypeAnnotationFromAccessor(anotherAccessor);
                         if (type) {
                             accessorWithTypeAnnotation = anotherAccessor;
@@ -1265,7 +1266,7 @@ namespace ts {
                 write("(");
             }
 
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
 
             // Parameters
@@ -1279,7 +1280,7 @@ namespace ts {
             }
 
             // If this is not a constructor and is not private, emit the return type
-            let isFunctionTypeOrConstructorType = node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.ConstructorType;
+            const isFunctionTypeOrConstructorType = node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.ConstructorType;
             if (isFunctionTypeOrConstructorType || node.parent.kind === SyntaxKind.TypeLiteral) {
                 // Emit type literal signature return type only if specified
                 if (node.type) {
@@ -1395,7 +1396,7 @@ namespace ts {
             }
 
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                const diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                 return diagnosticMessage !== undefined ? {
                     diagnosticMessage,
                     errorNode: node,
@@ -1468,7 +1469,7 @@ namespace ts {
                 }
                 else if (bindingPattern.kind === SyntaxKind.ArrayBindingPattern) {
                     write("[");
-                    let elements = bindingPattern.elements;
+                    const elements = bindingPattern.elements;
                     emitCommaList(elements, emitBindingElement);
                     if (elements && elements.hasTrailingComma) {
                         write(", ");
@@ -1479,7 +1480,7 @@ namespace ts {
 
             function emitBindingElement(bindingElement: BindingElement) {
                 function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                    const diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                     return diagnosticMessage !== undefined ? {
                         diagnosticMessage,
                         errorNode: bindingElement,
@@ -1618,13 +1619,12 @@ namespace ts {
 
     /* @internal */
     export function writeDeclarationFile(declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection) {
-        let emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit);
-        let emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath);
+        const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit);
+        const emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath);
         if (!emitSkipped) {
-            let declarationOutput = emitDeclarationResult.referencePathsOutput
+            const declarationOutput = emitDeclarationResult.referencePathsOutput
                 + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);
-            let compilerOptions = host.getCompilerOptions();
-            writeFile(host, emitterDiagnostics, declarationFilePath, declarationOutput, compilerOptions.emitBOM);
+            writeFile(host, emitterDiagnostics, declarationFilePath, declarationOutput, host.getCompilerOptions().emitBOM);
         }
         return emitSkipped;
 
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 6cb5858f8ee..ca31abceb85 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1012,7 +1012,7 @@
         "category": "Error",
         "code": 2354
     },
-    "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.": {
+    "A function whose declared type is neither 'void' nor 'any' must return a value.": {
         "category": "Error",
         "code": 2355
     },
@@ -1096,7 +1096,7 @@
         "category": "Error",
         "code": 2377
     },
-    "A 'get' accessor must return a value or consist of a single 'throw' statement.": {
+    "A 'get' accessor must return a value.": {
         "category": "Error",
         "code": 2378
     },
@@ -2266,14 +2266,6 @@
         "code": 6063
     },
 
-    "Specify JSX code generation: 'preserve' or 'react'": {
-        "category": "Message",
-        "code": 6080
-    },
-    "Argument for '--jsx' must be 'preserve' or 'react'.": {
-        "category": "Message",
-        "code": 6081
-    },
     "Enables experimental support for ES7 decorators.": {
         "category": "Message",
         "code": 6065
@@ -2302,14 +2294,43 @@
         "category": "Message",
         "code": 6072
     },
-    "Disallow inconsistently-cased references to the same file.": {
+    "Stylize errors and messages using color and context. (experimental)": {
         "category": "Message",
         "code": 6073
     },
-    "Allow javascript files to be compiled.": {
+    "Do not report errors on unused labels.": {
         "category": "Message",
         "code": 6074
     },
+    "Report error when not all code paths in function return a value.": {
+        "category": "Message",
+        "code": 6075
+    },
+    "Report errors for fallthrough cases in switch statement.": {
+        "category": "Message",
+        "code": 6076
+    },
+    "Do not report errors on unreachable code.": {
+        "category": "Message",
+        "code": 6077
+    },
+    "Disallow inconsistently-cased references to the same file.": {
+        "category": "Message",
+        "code": 6078
+    },
+
+    "Specify JSX code generation: 'preserve' or 'react'": {
+        "category": "Message",
+        "code": 6080
+    },
+    "Argument for '--jsx' must be 'preserve' or 'react'.": {
+        "category": "Message",
+        "code": 6081
+    },
+    "Allow javascript files to be compiled.": {
+        "category": "Message",
+        "code": 6082
+    },
 
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
@@ -2379,8 +2400,22 @@
         "category": "Error",
         "code": 7026
     },
-
-
+    "Unreachable code detected.": {
+        "category": "Error",
+        "code": 7027
+    },
+    "Unused label.": {
+        "category": "Error",
+        "code": 7028
+    },
+    "Fallthrough case in switch.": {
+        "category": "Error",
+        "code": 7029
+    },
+    "Not all code paths return a value.": {
+        "category": "Error",
+        "code": 7030
+    },    
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index d3fc80a3c5e..eb4b9a6218f 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -9,7 +9,13 @@ namespace ts {
 
     type DependencyGroup = Array<ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration>;
 
-    let entities: Map<number> = {
+    const enum Jump {
+        Break       = 1 << 1,
+        Continue    = 1 << 2,
+        Return      = 1 << 3
+    }
+
+    const entities: Map<number> = {
         "quot": 0x0022,
         "amp": 0x0026,
         "apos": 0x0027,
@@ -318,13 +324,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
     });
 };`;
 
-        let compilerOptions = host.getCompilerOptions();
-        let languageVersion = compilerOptions.target || ScriptTarget.ES3;
-        let modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None;
-        let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
-        let emitterDiagnostics = createDiagnosticCollection();
+        const compilerOptions = host.getCompilerOptions();
+        const languageVersion = compilerOptions.target || ScriptTarget.ES3;
+        const modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None;
+        const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
+        const emitterDiagnostics = createDiagnosticCollection();
         let emitSkipped = false;
-        let newLine = host.getNewLine();
+        const newLine = host.getNewLine();
 
         forEachExpectedEmitFile(host, emitFile, targetSourceFile);
 
@@ -334,14 +340,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             sourceMaps: sourceMapDataList
         };
 
-        function isNodeDescendentOf(node: Node, ancestor: Node): boolean {
-            while (node) {
-                if (node === ancestor) return true;
-                node = node.parent;
-            }
-            return false;
-        }
-
         function isUniqueLocalName(name: string, container: Node): boolean {
             for (let node = container; isNodeDescendentOf(node, container); node = node.nextContainer) {
                 if (node.locals && hasProperty(node.locals, name)) {
@@ -354,12 +352,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             return true;
         }
 
-        const enum Jump {
-            Break       = 1 << 1,
-            Continue    = 1 << 2,
-            Return      = 1 << 3
-        }
-
         interface ConvertedLoopState {
             /*
              * set of labels that occured inside the converted loop
@@ -454,8 +446,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
         }
 
         function emitJavaScript(jsFilePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {
-            let writer = createTextWriter(newLine);
-            let { write, writeTextOfNode, writeLine, increaseIndent, decreaseIndent } = writer;
+            const writer = createTextWriter(newLine);
+            const { write, writeTextOfNode, writeLine, increaseIndent, decreaseIndent } = writer;
 
             let currentSourceFile: SourceFile;
             // name of an exporter function if file is a System external module
@@ -466,8 +458,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             // var x;... exporter("x", x = 1)
             let exportFunctionForFile: string;
 
-            let generatedNameSet: Map<string> = {};
-            let nodeToGeneratedName: string[] = [];
+            const generatedNameSet: Map<string> = {};
+            const nodeToGeneratedName: string[] = [];
             let computedPropertyNamesToGeneratedNames: string[];
 
             let convertedLoopState: ConvertedLoopState;
@@ -520,9 +512,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             let sourceMapData: SourceMapData;
 
             /** If removeComments is true, no leading-comments needed to be emitted **/
-            let emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos: number) { } : emitLeadingCommentsOfPositionWorker;
+            const emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos: number) { } : emitLeadingCommentsOfPositionWorker;
 
-            let moduleEmitDelegates: Map<(node: SourceFile) => void> = {
+            const moduleEmitDelegates: Map<(node: SourceFile) => void> = {
                 [ModuleKind.ES6]: emitES6Module,
                 [ModuleKind.AMD]: emitAMDModule,
                 [ModuleKind.System]: emitSystemModule,
@@ -558,18 +550,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             // Note that names generated by makeTempVariableName and makeUniqueName will never conflict.
             function makeTempVariableName(flags: TempFlags): string {
                 if (flags && !(tempFlags & flags)) {
-                    let name = flags === TempFlags._i ? "_i" : "_n";
+                    const name = flags === TempFlags._i ? "_i" : "_n";
                     if (isUniqueName(name)) {
                         tempFlags |= flags;
                         return name;
                     }
                 }
                 while (true) {
-                    let count = tempFlags & TempFlags.CountMask;
+                    const count = tempFlags & TempFlags.CountMask;
                     tempFlags++;
                     // Skip over 'i' and 'n'
                     if (count !== 8 && count !== 13) {
-                        let name = count < 26 ? "_" + String.fromCharCode(CharacterCodes.a + count) : "_" + (count - 26);
+                        const name = count < 26 ? "_" + String.fromCharCode(CharacterCodes.a + count) : "_" + (count - 26);
                         if (isUniqueName(name)) {
                             return name;
                         }
@@ -588,7 +580,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 let i = 1;
                 while (true) {
-                    let generatedName = baseName + i;
+                    const generatedName = baseName + i;
                     if (isUniqueName(generatedName)) {
                         return generatedNameSet[generatedName] = generatedName;
                     }
@@ -597,14 +589,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {
-                let name = node.name.text;
+                const name = node.name.text;
                 // Use module/enum name itself if it is unique, otherwise make a unique variation
                 return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
             }
 
             function generateNameForImportOrExportDeclaration(node: ImportDeclaration | ExportDeclaration) {
-                let expr = getExternalModuleName(node);
-                let baseName = expr.kind === SyntaxKind.StringLiteral ?
+                const expr = getExternalModuleName(node);
+                const baseName = expr.kind === SyntaxKind.StringLiteral ?
                     escapeIdentifier(makeIdentifierFromModuleName((<LiteralExpression>expr).text)) : "module";
                 return makeUniqueName(baseName);
             }
@@ -637,7 +629,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function getGeneratedNameForNode(node: Node) {
-                let id = getNodeId(node);
+                const id = getNodeId(node);
                 return nodeToGeneratedName[id] || (nodeToGeneratedName[id] = unescapeIdentifier(generateNameForNode(node)));
             }
 
@@ -648,8 +640,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 let sourceMapSourceIndex = -1;
 
                 // Names and its index map
-                let sourceMapNameIndexMap: Map<number> = {};
-                let sourceMapNameIndices: number[] = [];
+                const sourceMapNameIndexMap: Map<number> = {};
+                const sourceMapNameIndices: number[] = [];
                 function getSourceMapNameIndex() {
                     return sourceMapNameIndices.length ? lastOrUndefined(sourceMapNameIndices) : -1;
                 }
@@ -745,14 +737,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function recordSourceMapSpan(pos: number) {
-                    let sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos);
+                    const sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos);
 
                     // Convert the location to be one-based.
                     sourceLinePos.line++;
                     sourceLinePos.character++;
 
-                    let emittedLine = writer.getLine();
-                    let emittedColumn = writer.getColumn();
+                    const emittedLine = writer.getLine();
+                    const emittedColumn = writer.getColumn();
 
                     // If this location wasn't recorded or the location in source is going backwards, record the span
                     if (!lastRecordedSourceMapSpan ||
@@ -792,9 +784,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function writeTextWithSpanRecord(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {
-                    let tokenStartPos = ts.skipTrivia(currentSourceFile.text, startPos);
+                    const tokenStartPos = ts.skipTrivia(currentSourceFile.text, startPos);
                     recordSourceMapSpan(tokenStartPos);
-                    let tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn);
+                    const tokenEndPos = emitTokenText(tokenKind, tokenStartPos, emitFn);
                     recordSourceMapSpan(tokenEndPos);
                     return tokenEndPos;
                 }
@@ -803,7 +795,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     // Add the file to tsFilePaths
                     // If sourceroot option: Use the relative path corresponding to the common directory path
                     // otherwise source locations relative to map file location
-                    let sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;
+                    const sourcesDirectoryPath = compilerOptions.sourceRoot ? host.getCommonSourceDirectory() : sourceMapDir;
 
                     sourceMapData.sourceMapSources.push(getRelativePathToDirectoryOrUrl(sourcesDirectoryPath,
                         node.fileName,
@@ -831,12 +823,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     function recordScopeNameStart(scopeName: string) {
                         let scopeNameIndex = -1;
                         if (scopeName) {
-                            let parentIndex = getSourceMapNameIndex();
+                            const parentIndex = getSourceMapNameIndex();
                             if (parentIndex !== -1) {
                                 // Child scopes are always shown with a dot (even if they have no name),
                                 // unless it is a computed property. Then it is shown with brackets,
                                 // but the brackets are included in the name.
-                                let name = (<Declaration>node).name;
+                                const name = (<Declaration>node).name;
                                 if (!name || name.kind !== SyntaxKind.ComputedPropertyName) {
                                     scopeName = "." + scopeName;
                                 }
@@ -868,7 +860,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         node.kind === SyntaxKind.EnumDeclaration) {
                         // Declaration and has associated name use it
                         if ((<Declaration>node).name) {
-                            let name = (<Declaration>node).name;
+                            const name = (<Declaration>node).name;
                             // For computed property names, the text will include the brackets
                             scopeName = name.kind === SyntaxKind.ComputedPropertyName
                                 ? getTextOfNode(name)
@@ -894,7 +886,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 function serializeSourceMapContents(version: number, file: string, sourceRoot: string, sources: string[], names: string[], mappings: string, sourcesContent?: string[]) {
                     if (typeof JSON !== "undefined") {
-                        let map: any = {
+                        const map: any = {
                             version,
                             file,
                             sourceRoot,
@@ -927,7 +919,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 function writeJavaScriptAndSourceMapFile(emitOutput: string, writeByteOrderMark: boolean) {
                     encodeLastRecordedSourceMapSpan();
 
-                    let sourceMapText = serializeSourceMapContents(
+                    const sourceMapText = serializeSourceMapContents(
                         3,
                         sourceMapData.sourceMapFile,
                         sourceMapData.sourceMapSourceRoot,
@@ -941,7 +933,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     let sourceMapUrl: string;
                     if (compilerOptions.inlineSourceMap) {
                         // Encode the sourceMap into the sourceMap url
-                        let base64SourceMapText = convertToBase64(sourceMapText);
+                        const base64SourceMapText = convertToBase64(sourceMapText);
                         sourceMapData.jsSourceMappingURL = `data:application/json;base64,${base64SourceMapText}`;
                     }
                     else {
@@ -1039,7 +1031,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             // Create a temporary variable with a unique unused name.
             function createTempVariable(flags: TempFlags): Identifier {
-                let result = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
+                const result = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
                 result.text = makeTempVariableName(flags);
                 return result;
             }
@@ -1052,7 +1044,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function createAndRecordTempVariable(flags: TempFlags): Identifier {
-                let temp = createTempVariable(flags);
+                const temp = createTempVariable(flags);
                 recordTempDeclaration(temp);
 
                 return temp;
@@ -1073,7 +1065,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitTokenText(tokenKind: SyntaxKind, startPos: number, emitFn?: () => void) {
-                let tokenString = tokenToString(tokenKind);
+                const tokenString = tokenToString(tokenKind);
                 if (emitFn) {
                     emitFn();
                 }
@@ -1167,7 +1159,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             write(", ");
                         }
                     }
-                    let node = nodes[start + i];
+                    const node = nodes[start + i];
                     // This emitting is to make sure we emit following comment properly
                     //   ...(x, /*comment1*/ y)...
                     //         ^ => node.pos
@@ -1219,7 +1211,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitLiteral(node: LiteralExpression) {
-                let text = getLiteralText(node);
+                const text = getLiteralText(node);
 
                 if ((compilerOptions.sourceMap || compilerOptions.inlineSourceMap) && (node.kind === SyntaxKind.StringLiteral || isTemplateLiteralKind(node.kind))) {
                     writer.writeLiteral(text);
@@ -1280,7 +1272,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // thus we need to remove those characters.
                 // First template piece starts with "`", others with "}"
                 // Last template piece ends with "`", others with "${"
-                let isLast = node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.TemplateTail;
+                const isLast = node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.TemplateTail;
                 text = text.substring(1, text.length - (isLast ? 1 : 2));
 
                 // Newline normalization:
@@ -1308,7 +1300,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitDownlevelTaggedTemplate(node: TaggedTemplateExpression) {
-                let tempVariable = createAndRecordTempVariable(TempFlags.Auto);
+                const tempVariable = createAndRecordTempVariable(TempFlags.Auto);
                 write("(");
                 emit(tempVariable);
                 write(" = ");
@@ -1328,7 +1320,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (node.template.kind === SyntaxKind.TemplateExpression) {
                     forEach((<TemplateExpression>node.template).templateSpans, templateSpan => {
                         write(", ");
-                        let needsParens = templateSpan.expression.kind === SyntaxKind.BinaryExpression
+                        const needsParens = templateSpan.expression.kind === SyntaxKind.BinaryExpression
                             && (<BinaryExpression>templateSpan.expression).operatorToken.kind === SyntaxKind.CommaToken;
                         emitParenthesizedIf(templateSpan.expression, needsParens);
                     });
@@ -1344,7 +1336,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     return;
                 }
 
-                let emitOuterParens = isExpression(node.parent)
+                const emitOuterParens = isExpression(node.parent)
                     && templateNeedsParens(node, <Expression>node.parent);
 
                 if (emitOuterParens) {
@@ -1358,7 +1350,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 for (let i = 0, n = node.templateSpans.length; i < n; i++) {
-                    let templateSpan = node.templateSpans[i];
+                    const templateSpan = node.templateSpans[i];
 
                     // Check if the expression has operands and binds its operands less closely than binary '+'.
                     // If it does, we need to wrap the expression in parentheses. Otherwise, something like
@@ -1369,7 +1361,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     //    ("abc" + 1) << (2 + "")
                     // rather than
                     //    "abc" + (1 << 2) + ""
-                    let needsParens = templateSpan.expression.kind !== SyntaxKind.ParenthesizedExpression
+                    const needsParens = templateSpan.expression.kind !== SyntaxKind.ParenthesizedExpression
                         && comparePrecedenceToBinaryPlus(templateSpan.expression) !== Comparison.GreaterThan;
 
                     if (i > 0 || headEmitted) {
@@ -1512,7 +1504,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function emitJsxElement(openingNode: JsxOpeningLikeElement, children?: JsxChild[]) {
-                    let syntheticReactRef = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
+                    const syntheticReactRef = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
                     syntheticReactRef.text = "React";
                     syntheticReactRef.parent = openingNode;
 
@@ -1531,7 +1523,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     else {
                         // Either emit one big object literal (no spread attribs), or
                         // a call to React.__spread
-                        let attrs = openingNode.attributes;
+                        const attrs = openingNode.attributes;
                         if (forEach(attrs, attr => attr.kind === SyntaxKind.JsxSpreadAttribute)) {
                             emitExpressionIdentifier(syntheticReactRef);
                             write(".__spread(");
@@ -1595,7 +1587,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                             // Don't emit empty strings
                             if (children[i].kind === SyntaxKind.JsxText) {
-                                let text = getTextToEmit(<JsxText>children[i]);
+                                const text = getTextToEmit(<JsxText>children[i]);
                                 if (text !== undefined) {
                                     write(", \"");
                                     write(text);
@@ -1754,7 +1746,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function isExpressionIdentifier(node: Node): boolean {
-                let parent = node.parent;
+                const parent = node.parent;
                 switch (parent.kind) {
                     case SyntaxKind.ArrayLiteralExpression:
                     case SyntaxKind.AsExpression:
@@ -1822,7 +1814,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     return;
                 }
 
-                let container = resolver.getReferencedExportContainer(node);
+                const container = resolver.getReferencedExportContainer(node);
                 if (container) {
                     if (container.kind === SyntaxKind.SourceFile) {
                         // Identifier references module export
@@ -1838,7 +1830,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 else {
                     if (modulekind !== ModuleKind.ES6) {
-                        let declaration = resolver.getReferencedImportDeclaration(node);
+                        const declaration = resolver.getReferencedImportDeclaration(node);
                         if (declaration) {
                             if (declaration.kind === SyntaxKind.ImportClause) {
                                 // Identifier references default import
@@ -1849,8 +1841,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             else if (declaration.kind === SyntaxKind.ImportSpecifier) {
                                 // Identifier references named import
                                 write(getGeneratedNameForNode(<ImportDeclaration>declaration.parent.parent.parent));
-                                let name =  (<ImportSpecifier>declaration).propertyName || (<ImportSpecifier>declaration).name;
-                                let identifier = getSourceTextOfNodeFromSourceFile(currentSourceFile, name);
+                                const name =  (<ImportSpecifier>declaration).propertyName || (<ImportSpecifier>declaration).name;
+                                const identifier = getSourceTextOfNodeFromSourceFile(currentSourceFile, name);
                                 if (languageVersion === ScriptTarget.ES3 && identifier === "default") {
                                     write(`["default"]`);
                                 }
@@ -1864,7 +1856,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
 
                     if (languageVersion !== ScriptTarget.ES6) {
-                        let declaration = resolver.getReferencedNestedRedeclaration(node);
+                        const declaration = resolver.getReferencedNestedRedeclaration(node);
                         if (declaration) {
                             write(getGeneratedNameForNode(declaration.name));
                             return;
@@ -1882,7 +1874,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function isNameOfNestedRedeclaration(node: Identifier) {
                 if (languageVersion < ScriptTarget.ES6) {
-                    let parent = node.parent;
+                    const parent = node.parent;
                     switch (parent.kind) {
                         case SyntaxKind.BindingElement:
                         case SyntaxKind.ClassDeclaration:
@@ -1898,7 +1890,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (convertedLoopState) {
                     if (node.text == "arguments" && resolver.isArgumentsLocalBinding(node)) {
                         // in converted loop body arguments cannot be used directly.
-                        let name = convertedLoopState.argumentsName || (convertedLoopState.argumentsName = makeUniqueName("arguments"));
+                        const name = convertedLoopState.argumentsName || (convertedLoopState.argumentsName = makeUniqueName("arguments"));
                         write(name);
                         return;
                     }
@@ -1935,7 +1927,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write("super");
                 }
                 else {
-                    let flags = resolver.getNodeCheckFlags(node);
+                    const flags = resolver.getNodeCheckFlags(node);
                     if (flags & NodeCheckFlags.SuperInstance) {
                         write("_super.prototype");
                     }
@@ -1947,14 +1939,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitObjectBindingPattern(node: BindingPattern) {
                 write("{ ");
-                let elements = node.elements;
+                const elements = node.elements;
                 emitList(elements, 0, elements.length, /*multiLine*/ false, /*trailingComma*/ elements.hasTrailingComma);
                 write(" }");
             }
 
             function emitArrayBindingPattern(node: BindingPattern) {
                 write("[");
-                let elements = node.elements;
+                const elements = node.elements;
                 emitList(elements, 0, elements.length, /*multiLine*/ false, /*trailingComma*/ elements.hasTrailingComma);
                 write("]");
             }
@@ -1993,7 +1985,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitAwaitExpression(node: AwaitExpression) {
-                let needsParenthesis = needsParenthesisForAwaitExpressionAsYield(node);
+                const needsParenthesis = needsParenthesisForAwaitExpressionAsYield(node);
                 if (needsParenthesis) {
                     write("(");
                 }
@@ -2034,7 +2026,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             function emitListWithSpread(elements: Expression[], needsUniqueCopy: boolean, multiLine: boolean, trailingComma: boolean, useConcat: boolean) {
                 let pos = 0;
                 let group = 0;
-                let length = elements.length;
+                const length = elements.length;
                 while (pos < length) {
                     // Emit using the pattern <group0>.concat(<group1>, <group2>, ...)
                     if (group === 1 && useConcat) {
@@ -2082,7 +2074,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitArrayLiteral(node: ArrayLiteralExpression) {
-                let elements = node.elements;
+                const elements = node.elements;
                 if (elements.length === 0) {
                     write("[]");
                 }
@@ -2106,7 +2098,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write("{");
 
                 if (numElements > 0) {
-                    let properties = node.properties;
+                    const properties = node.properties;
 
                     // If we are not doing a downlevel transformation for object literals,
                     // then try to preserve the original shape of the object literal.
@@ -2115,7 +2107,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         emitLinePreservingList(node, properties, /* allowTrailingComma */ languageVersion >= ScriptTarget.ES5, /* spacesBetweenBraces */ true);
                     }
                     else {
-                        let multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
+                        const multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
                         if (!multiLine) {
                             write(" ");
                         }
@@ -2138,8 +2130,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitDownlevelObjectLiteralWithComputedProperties(node: ObjectLiteralExpression, firstComputedPropertyIndex: number) {
-                let multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
-                let properties = node.properties;
+                const multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
+                const properties = node.properties;
 
                 write("(");
 
@@ -2149,7 +2141,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 // For computed properties, we need to create a unique handle to the object
                 // literal so we can modify it without risking internal assignments tainting the object.
-                let tempVar = createAndRecordTempVariable(TempFlags.Auto);
+                const tempVar = createAndRecordTempVariable(TempFlags.Auto);
 
                 // Write out the first non-computed properties
                 // (or all properties if none of them are computed),
@@ -2161,12 +2153,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 for (let i = firstComputedPropertyIndex, n = properties.length; i < n; i++) {
                     writeComma();
 
-                    let property = properties[i];
+                    const property = properties[i];
 
                     emitStart(property);
                     if (property.kind === SyntaxKind.GetAccessor || property.kind === SyntaxKind.SetAccessor) {
                         // TODO (drosen): Reconcile with 'emitMemberFunctions'.
-                        let accessors = getAllAccessorDeclarations(node.properties, <AccessorDeclaration>property);
+                        const accessors = getAllAccessorDeclarations(node.properties, <AccessorDeclaration>property);
                         if (property !== accessors.firstAccessor) {
                             continue;
                         }
@@ -2257,10 +2249,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitObjectLiteral(node: ObjectLiteralExpression): void {
-                let properties = node.properties;
+                const properties = node.properties;
 
                 if (languageVersion < ScriptTarget.ES6) {
-                    let numProperties = properties.length;
+                    const numProperties = properties.length;
 
                     // Find the first computed property.
                     // Everything until that point can be emitted as part of the initial object literal.
@@ -2272,7 +2264,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         }
                     }
 
-                    let hasComputedProperty = numInitialNonComputedProperties !== properties.length;
+                    const hasComputedProperty = numInitialNonComputedProperties !== properties.length;
                     if (hasComputedProperty) {
                         emitDownlevelObjectLiteralWithComputedProperties(node, numInitialNonComputedProperties);
                         return;
@@ -2285,7 +2277,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function createBinaryExpression(left: Expression, operator: SyntaxKind, right: Expression, startsOnNewLine?: boolean): BinaryExpression {
-                let result = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression, startsOnNewLine);
+                const result = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression, startsOnNewLine);
                 result.operatorToken = createSynthesizedNode(operator);
                 result.left = left;
                 result.right = right;
@@ -2294,7 +2286,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function createPropertyAccessExpression(expression: Expression, name: Identifier): PropertyAccessExpression {
-                let result = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
+                const result = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
                 result.expression = parenthesizeForAccess(expression);
                 result.dotToken = createSynthesizedNode(SyntaxKind.DotToken);
                 result.name = name;
@@ -2303,7 +2295,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function createElementAccessExpression(expression: Expression, argumentExpression: Expression): ElementAccessExpression {
-                let result = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
+                const result = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);
                 result.expression = parenthesizeForAccess(expression);
                 result.argumentExpression = argumentExpression;
 
@@ -2331,7 +2323,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                     return <LeftHandSideExpression>expr;
                 }
-                let node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);
+                const node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);
                 node.expression = expr;
                 return node;
             }
@@ -2370,7 +2362,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             // Return true if identifier resolves to an exported member of a namespace
             function isNamespaceExportReference(node: Identifier) {
-                let container = resolver.getReferencedExportContainer(node);
+                const container = resolver.getReferencedExportContainer(node);
                 return container && container.kind !== SyntaxKind.SourceFile;
             }
 
@@ -2400,11 +2392,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function tryEmitConstantValue(node: PropertyAccessExpression | ElementAccessExpression): boolean {
-                let constantValue = tryGetConstEnumValue(node);
+                const constantValue = tryGetConstEnumValue(node);
                 if (constantValue !== undefined) {
                     write(constantValue.toString());
                     if (!compilerOptions.removeComments) {
-                        let propertyName: string = node.kind === SyntaxKind.PropertyAccessExpression ? declarationNameToString((<PropertyAccessExpression>node).name) : getTextOfNode((<ElementAccessExpression>node).argumentExpression);
+                        const propertyName: string = node.kind === SyntaxKind.PropertyAccessExpression ? declarationNameToString((<PropertyAccessExpression>node).name) : getTextOfNode((<ElementAccessExpression>node).argumentExpression);
                         write(" /* " + propertyName + " */");
                     }
                     return true;
@@ -2426,10 +2418,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             // If the code is not indented, an optional valueToWriteWhenNotIndenting will be
             // emitted instead.
             function indentIfOnDifferentLines(parent: Node, node1: Node, node2: Node, valueToWriteWhenNotIndenting?: string): boolean {
-                let realNodesAreOnDifferentLines = !nodeIsSynthesized(parent) && !nodeEndIsOnSameLineAsNodeStart(node1, node2);
+                const realNodesAreOnDifferentLines = !nodeIsSynthesized(parent) && !nodeEndIsOnSameLineAsNodeStart(node1, node2);
 
                 // Always use a newline for synthesized code if the synthesizer desires it.
-                let synthesizedNodeIsOnDifferentLine = synthesizedNodeStartsOnNewLine(node2);
+                const synthesizedNodeIsOnDifferentLine = synthesizedNodeStartsOnNewLine(node2);
 
                 if (realNodesAreOnDifferentLines || synthesizedNodeIsOnDifferentLine) {
                     increaseIndent();
@@ -2450,7 +2442,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 emit(node.expression);
-                let indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken);
+                const indentedBeforeDot = indentIfOnDifferentLines(node, node.expression, node.dotToken);
 
                 // 1 .toString is a valid property access, emit a space after the literal
                 // Also emit a space if expression is a integer const enum value - it will appear in generated code as numeric literal
@@ -2458,12 +2450,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (!indentedBeforeDot) {
                     if (node.expression.kind === SyntaxKind.NumericLiteral) {
                         // check if numeric literal was originally written with a dot
-                        let text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node.expression);
+                        const text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node.expression);
                         shouldEmitSpace = text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
                     }
                     else {
                         // check if constant enum value is integer
-                        let constantValue = tryGetConstEnumValue(node.expression);
+                        const constantValue = tryGetConstEnumValue(node.expression);
                         // isFinite handles cases when constantValue is undefined
                         shouldEmitSpace = isFinite(constantValue) && Math.floor(constantValue) === constantValue;
                     }
@@ -2476,7 +2468,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(".");
                 }
 
-                let indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name);
+                const indentedAfterDot = indentIfOnDifferentLines(node, node.dotToken, node.name);
                 emit(node.name);
                 decreaseIndentIf(indentedBeforeDot, indentedAfterDot);
             }
@@ -2492,7 +2484,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitEntityNameAsExpression(node.left, useFallback);
                 }
                 else if (useFallback) {
-                    let temp = createAndRecordTempVariable(TempFlags.Auto);
+                    const temp = createAndRecordTempVariable(TempFlags.Auto);
                     write("(");
                     emitNodeWithoutSourceMap(temp);
                     write(" = ");
@@ -2552,7 +2544,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emit(node);
                     return node;
                 }
-                let temp = createAndRecordTempVariable(TempFlags.Auto);
+                const temp = createAndRecordTempVariable(TempFlags.Auto);
 
                 write("(");
                 emit(temp);
@@ -2564,7 +2556,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitCallWithSpread(node: CallExpression) {
                 let target: Expression;
-                let expr = skipParentheses(node.expression);
+                const expr = skipParentheses(node.expression);
                 if (expr.kind === SyntaxKind.PropertyAccessExpression) {
                     // Target will be emitted as "this" argument
                     target = emitCallTarget((<PropertyAccessExpression>expr).expression);
@@ -2658,7 +2650,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     hasSpreadElement(node.arguments)) {
 
                     write("(");
-                    let target = emitCallTarget(node.expression);
+                    const target = emitCallTarget(node.expression);
                     write(".bind.apply(");
                     emit(target);
                     write(", [void 0].concat(");
@@ -2790,7 +2782,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // expression a prefix increment whose operand is a plus expression - (++(+x))
                 // The same is true of minus of course.
                 if (node.operand.kind === SyntaxKind.PrefixUnaryExpression) {
-                    let operand = <PrefixUnaryExpression>node.operand;
+                    const operand = <PrefixUnaryExpression>node.operand;
                     if (node.operator === SyntaxKind.PlusToken && (operand.operator === SyntaxKind.PlusToken || operand.operator === SyntaxKind.PlusPlusToken)) {
                         write(" ");
                     }
@@ -2869,7 +2861,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
              * @param node a binary expression node containing exponentiationOperator (**, **=)
              */
             function emitExponentiationOperator(node: BinaryExpression) {
-                let leftHandSideExpression = node.left;
+                const leftHandSideExpression = node.left;
                 if (node.operatorToken.kind === SyntaxKind.AsteriskAsteriskEqualsToken) {
                     let synthesizedLHS: ElementAccessExpression | PropertyAccessExpression;
                     let shouldEmitParentheses = false;
@@ -2879,12 +2871,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                         synthesizedLHS = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression, /*startsOnNewLine*/ false);
 
-                        let identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
+                        const identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
                         synthesizedLHS.expression = identifier;
 
                         if (leftHandSideExpression.argumentExpression.kind !== SyntaxKind.NumericLiteral &&
                             leftHandSideExpression.argumentExpression.kind !== SyntaxKind.StringLiteral) {
-                            let tempArgumentExpression = createAndRecordTempVariable(TempFlags._i);
+                            const tempArgumentExpression = createAndRecordTempVariable(TempFlags._i);
                             (<ElementAccessExpression>synthesizedLHS).argumentExpression = tempArgumentExpression;
                             emitAssignment(tempArgumentExpression, leftHandSideExpression.argumentExpression, /*shouldEmitCommaBeforeAssignment*/ true);
                         }
@@ -2898,7 +2890,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         write("(");
                         synthesizedLHS = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression, /*startsOnNewLine*/ false);
 
-                        let identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldemitCommaBeforeAssignment*/ false);
+                        const identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldemitCommaBeforeAssignment*/ false);
                         synthesizedLHS.expression = identifier;
 
                         (<PropertyAccessExpression>synthesizedLHS).dotToken = leftHandSideExpression.dotToken;
@@ -2957,9 +2949,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         //   emitted as
                         //      3
                         //          + 2;
-                        let indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== SyntaxKind.CommaToken ? " " : undefined);
+                        const indentedBeforeOperator = indentIfOnDifferentLines(node, node.left, node.operatorToken, node.operatorToken.kind !== SyntaxKind.CommaToken ? " " : undefined);
                         write(tokenToString(node.operatorToken.kind));
-                        let indentedAfterOperator = indentIfOnDifferentLines(node, node.operatorToken, node.right, " ");
+                        const indentedAfterOperator = indentIfOnDifferentLines(node, node.operatorToken, node.right, " ");
                         emit(node.right);
                         decreaseIndentIf(indentedBeforeOperator, indentedAfterOperator);
                     }
@@ -2976,14 +2968,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitConditionalExpression(node: ConditionalExpression) {
                 emit(node.condition);
-                let indentedBeforeQuestion = indentIfOnDifferentLines(node, node.condition, node.questionToken, " ");
+                const indentedBeforeQuestion = indentIfOnDifferentLines(node, node.condition, node.questionToken, " ");
                 write("?");
-                let indentedAfterQuestion = indentIfOnDifferentLines(node, node.questionToken, node.whenTrue, " ");
+                const indentedAfterQuestion = indentIfOnDifferentLines(node, node.questionToken, node.whenTrue, " ");
                 emit(node.whenTrue);
                 decreaseIndentIf(indentedBeforeQuestion, indentedAfterQuestion);
-                let indentedBeforeColon = indentIfOnDifferentLines(node, node.whenTrue, node.colonToken, " ");
+                const indentedBeforeColon = indentIfOnDifferentLines(node, node.whenTrue, node.colonToken, " ");
                 write(":");
-                let indentedAfterColon = indentIfOnDifferentLines(node, node.colonToken, node.whenFalse, " ");
+                const indentedAfterColon = indentIfOnDifferentLines(node, node.colonToken, node.whenFalse, " ");
                 emit(node.whenFalse);
                 decreaseIndentIf(indentedBeforeColon, indentedAfterColon);
             }
@@ -3003,7 +2995,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function isSingleLineEmptyBlock(node: Node) {
                 if (node && node.kind === SyntaxKind.Block) {
-                    let block = <Block>node;
+                    const block = <Block>node;
                     return block.statements.length === 0 && nodeEndIsOnSameLineAsNodeStart(block, block);
                 }
             }
@@ -3164,7 +3156,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitVariableDeclarationListSkippingUninitializedEntries(list: VariableDeclarationList): boolean {
                 let started = false;
-                for (let decl of list.declarations) {
+                for (const decl of list.declarations) {
                     if (!decl.initializer) {
                         continue;
                     }
@@ -3442,8 +3434,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         return;
                     }
 
-                    for (let labelText in table) {
-                        let labelMarker = table[labelText];
+                    for (const labelText in table) {
+                        const labelMarker = table[labelText];
                         writeLine();
                         write(`case "${labelMarker}": `);
                         // if there are no outer converted loop or outer label in question is located inside outer converted loop
@@ -3475,8 +3467,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
                 if (node.initializer && node.initializer.kind === SyntaxKind.VariableDeclarationList) {
-                    let variableDeclarationList = <VariableDeclarationList>node.initializer;
-                    let startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos);
+                    const variableDeclarationList = <VariableDeclarationList>node.initializer;
+                    const startIsEmitted = tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos);
                     if (startIsEmitted) {
                         emitCommaList(variableDeclarationList.declarations);
                     }
@@ -3515,7 +3507,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
                 if (node.initializer.kind === SyntaxKind.VariableDeclarationList) {
-                    let variableDeclarationList = <VariableDeclarationList>node.initializer;
+                    const variableDeclarationList = <VariableDeclarationList>node.initializer;
                     if (variableDeclarationList.declarations.length >= 1) {
                         tryEmitStartOfVariableDeclarationList(variableDeclarationList, endPos);
                         emit(variableDeclarationList.declarations[0]);
@@ -3580,10 +3572,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 //
                 //     for (let v of arr) { }
                 //
-                // we don't want to emit a temporary variable for the RHS, just use it directly.
-                let rhsIsIdentifier = node.expression.kind === SyntaxKind.Identifier;
-                let counter = createTempVariable(TempFlags._i);
-                let rhsReference = rhsIsIdentifier ? <Identifier>node.expression : createTempVariable(TempFlags.Auto);
+                // we can't reuse 'arr' because it might be modified within the body of the loop.
+                const counter = createTempVariable(TempFlags._i);
+                const rhsReference = createSynthesizedNode(SyntaxKind.Identifier) as Identifier;
+                rhsReference.text = node.expression.kind === SyntaxKind.Identifier ?
+                    makeUniqueName((<Identifier>node.expression).text) :
+                    makeTempVariableName(TempFlags.Auto);
 
                 // This is the let keyword for the counter and rhsReference. The let keyword for
                 // the LHS will be emitted inside the body.
@@ -3595,15 +3589,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(" = 0");
                 emitEnd(node.expression);
 
-                if (!rhsIsIdentifier) {
-                    // , _a = expr
-                    write(", ");
-                    emitStart(node.expression);
-                    emitNodeWithoutSourceMap(rhsReference);
-                    write(" = ");
-                    emitNodeWithoutSourceMap(node.expression);
-                    emitEnd(node.expression);
-                }
+                // , _a = expr
+                write(", ");
+                emitStart(node.expression);
+                emitNodeWithoutSourceMap(rhsReference);
+                write(" = ");
+                emitNodeWithoutSourceMap(node.expression);
+                emitEnd(node.expression);
 
                 write("; ");
 
@@ -3632,13 +3624,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 // Initialize LHS
                 // let v = _a[_i];
-                let rhsIterationValue = createElementAccessExpression(rhsReference, counter);
+                const rhsIterationValue = createElementAccessExpression(rhsReference, counter);
                 emitStart(node.initializer);
                 if (node.initializer.kind === SyntaxKind.VariableDeclarationList) {
                     write("var ");
-                    let variableDeclarationList = <VariableDeclarationList>node.initializer;
+                    const variableDeclarationList = <VariableDeclarationList>node.initializer;
                     if (variableDeclarationList.declarations.length > 0) {
-                        let declaration = variableDeclarationList.declarations[0];
+                        const declaration = variableDeclarationList.declarations[0];
                         if (isBindingPattern(declaration.name)) {
                             // This works whether the declaration is a var, let, or const.
                             // It will use rhsIterationValue _a[_i] as the initializer.
@@ -3663,7 +3655,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 else {
                     // Initializer is an expression. Emit the expression in the body, so that it's
                     // evaluated on every iteration.
-                    let assignmentExpression = createBinaryExpression(<Expression>node.initializer, SyntaxKind.EqualsToken, rhsIterationValue, /*startsOnNewLine*/ false);
+                    const assignmentExpression = createBinaryExpression(<Expression>node.initializer, SyntaxKind.EqualsToken, rhsIterationValue, /*startsOnNewLine*/ false);
                     if (node.initializer.kind === SyntaxKind.ArrayLiteralExpression || node.initializer.kind === SyntaxKind.ObjectLiteralExpression) {
                         // This is a destructuring pattern, so call emitDestructuring instead of emit. Calling emit will not work, because it will cause
                         // the BinaryExpression to be passed in instead of the expression statement, which will cause emitDestructuring to crash.
@@ -3843,7 +3835,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitCatchClause(node: CatchClause) {
                 writeLine();
-                let endPos = emitToken(SyntaxKind.CatchKeyword, node.pos);
+                const endPos = emitToken(SyntaxKind.CatchKeyword, node.pos);
                 write(" ");
                 emitToken(SyntaxKind.OpenParenToken, endPos);
                 emit(node.variableDeclaration);
@@ -3889,14 +3881,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitContainingModuleName(node: Node) {
-                let container = getContainingModule(node);
+                const container = getContainingModule(node);
                 write(container ? getGeneratedNameForNode(container) : "exports");
             }
 
             function emitModuleMemberName(node: Declaration) {
                 emitStart(node.name);
                 if (getCombinedNodeFlags(node) & NodeFlags.Export) {
-                    let container = getContainingModule(node);
+                    const container = getContainingModule(node);
                     if (container) {
                         write(getGeneratedNameForNode(container));
                         write(".");
@@ -3910,9 +3902,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function createVoidZero(): Expression {
-                let zero = <LiteralExpression>createSynthesizedNode(SyntaxKind.NumericLiteral);
+                const zero = <LiteralExpression>createSynthesizedNode(SyntaxKind.NumericLiteral);
                 zero.text = "0";
-                let result = <VoidExpression>createSynthesizedNode(SyntaxKind.VoidExpression);
+                const result = <VoidExpression>createSynthesizedNode(SyntaxKind.VoidExpression);
                 result.expression = zero;
                 return result;
             }
@@ -3984,7 +3976,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 if (!exportEquals && exportSpecifiers && hasProperty(exportSpecifiers, name.text)) {
-                    for (let specifier of exportSpecifiers[name.text]) {
+                    for (const specifier of exportSpecifiers[name.text]) {
                         writeLine();
                         emitStart(specifier.name);
                         emitContainingModuleName(specifier);
@@ -4027,7 +4019,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(", ");
                 }
 
-                let exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name);
+                const exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(name);
 
                 if (exportChanged) {
                     write(`${exportFunctionForFile}("`);
@@ -4060,7 +4052,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
              * @param shouldEmitCommaBeforeAssignment a boolean indicating whether an assignment should prefix with comma
              */
             function emitTempVariableAssignment(expression: Expression, canDefineTempVariablesInPlace: boolean, shouldEmitCommaBeforeAssignment: boolean): Identifier {
-                let identifier = createTempVariable(TempFlags.Auto);
+                const identifier = createTempVariable(TempFlags.Auto);
                 if (!canDefineTempVariablesInPlace) {
                     recordTempDeclaration(identifier);
                 }
@@ -4077,8 +4069,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // because actual variable declarations are hoisted
                 let canDefineTempVariablesInPlace = false;
                 if (root.kind === SyntaxKind.VariableDeclaration) {
-                    let isExported = getCombinedNodeFlags(root) & NodeFlags.Export;
-                    let isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
+                    const isExported = getCombinedNodeFlags(root) & NodeFlags.Export;
+                    const isSourceLevelForSystemModuleKind = shouldHoistDeclarationInSystemJsModule(root);
                     canDefineTempVariablesInPlace = !isExported && !isSourceLevelForSystemModuleKind;
                 }
                 else if (root.kind === SyntaxKind.Parameter) {
@@ -4108,7 +4100,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         return expr;
                     }
 
-                    let identifier = emitTempVariableAssignment(expr, canDefineTempVariablesInPlace, emitCount > 0);
+                    const identifier = emitTempVariableAssignment(expr, canDefineTempVariablesInPlace, emitCount > 0);
                     emitCount++;
                     return identifier;
                 }
@@ -4118,7 +4110,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     // we need to generate a temporary variable
                     value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     // Return the expression 'value === void 0 ? defaultValue : value'
-                    let equals = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression);
+                    const equals = <BinaryExpression>createSynthesizedNode(SyntaxKind.BinaryExpression);
                     equals.left = value;
                     equals.operatorToken = createSynthesizedNode(SyntaxKind.EqualsEqualsEqualsToken);
                     equals.right = createVoidZero();
@@ -4126,7 +4118,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function createConditionalExpression(condition: Expression, whenTrue: Expression, whenFalse: Expression) {
-                    let cond = <ConditionalExpression>createSynthesizedNode(SyntaxKind.ConditionalExpression);
+                    const cond = <ConditionalExpression>createSynthesizedNode(SyntaxKind.ConditionalExpression);
                     cond.condition = condition;
                     cond.questionToken = createSynthesizedNode(SyntaxKind.QuestionToken);
                     cond.whenTrue = whenTrue;
@@ -4136,7 +4128,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function createNumericLiteral(value: number) {
-                    let node = <LiteralExpression>createSynthesizedNode(SyntaxKind.NumericLiteral);
+                    const node = <LiteralExpression>createSynthesizedNode(SyntaxKind.NumericLiteral);
                     node.text = "" + value;
                     return node;
                 }
@@ -4144,7 +4136,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 function createPropertyAccessForDestructuringProperty(object: Expression, propName: Identifier | LiteralExpression): Expression {
                     // We create a synthetic copy of the identifier in order to avoid the rewriting that might
                     // otherwise occur when the identifier is emitted.
-                    let syntheticName = <Identifier | LiteralExpression>createSynthesizedNode(propName.kind);
+                    const syntheticName = <Identifier | LiteralExpression>createSynthesizedNode(propName.kind);
                     syntheticName.text = propName.text;
                     if (syntheticName.kind !== SyntaxKind.Identifier) {
                         return createElementAccessExpression(object, syntheticName);
@@ -4153,8 +4145,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function createSliceCall(value: Expression, sliceIndex: number): CallExpression {
-                    let call = <CallExpression>createSynthesizedNode(SyntaxKind.CallExpression);
-                    let sliceIdentifier = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
+                    const call = <CallExpression>createSynthesizedNode(SyntaxKind.CallExpression);
+                    const sliceIdentifier = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
                     sliceIdentifier.text = "slice";
                     call.expression = createPropertyAccessExpression(value, sliceIdentifier);
                     call.arguments = <NodeArray<LiteralExpression>>createSynthesizedNodeArray();
@@ -4163,30 +4155,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function emitObjectLiteralAssignment(target: ObjectLiteralExpression, value: Expression) {
-                    let properties = target.properties;
+                    const properties = target.properties;
                     if (properties.length !== 1) {
                         // For anything but a single element destructuring we need to generate a temporary
                         // to ensure value is evaluated exactly once.
                         value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     }
-                    for (let p of properties) {
+                    for (const p of properties) {
                         if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
-                            let propName = <Identifier | LiteralExpression>(<PropertyAssignment>p).name;
-                            let target = p.kind === SyntaxKind.ShorthandPropertyAssignment ? <ShorthandPropertyAssignment>p : (<PropertyAssignment>p).initializer || propName;
+                            const propName = <Identifier | LiteralExpression>(<PropertyAssignment>p).name;
+                            const target = p.kind === SyntaxKind.ShorthandPropertyAssignment ? <ShorthandPropertyAssignment>p : (<PropertyAssignment>p).initializer || propName;
                             emitDestructuringAssignment(target, createPropertyAccessForDestructuringProperty(value, propName));
                         }
                     }
                 }
 
                 function emitArrayLiteralAssignment(target: ArrayLiteralExpression, value: Expression) {
-                    let elements = target.elements;
+                    const elements = target.elements;
                     if (elements.length !== 1) {
                         // For anything but a single element destructuring we need to generate a temporary
                         // to ensure value is evaluated exactly once.
                         value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true);
                     }
                     for (let i = 0; i < elements.length; i++) {
-                        let e = elements[i];
+                        const e = elements[i];
                         if (e.kind !== SyntaxKind.OmittedExpression) {
                             if (e.kind !== SyntaxKind.SpreadElementExpression) {
                                 emitDestructuringAssignment(e, createElementAccessExpression(value, createNumericLiteral(i)));
@@ -4222,7 +4214,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 function emitAssignmentExpression(root: BinaryExpression) {
-                    let target = root.left;
+                    const target = root.left;
                     let value = root.right;
 
                     if (isEmptyObjectLiteralOrArrayLiteral(target)) {
@@ -4268,10 +4260,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         }
 
                         for (let i = 0; i < numElements; i++) {
-                            let element = elements[i];
+                            const element = elements[i];
                             if (pattern.kind === SyntaxKind.ObjectBindingPattern) {
                                 // Rewrite element to a declaration with an initializer that fetches property
-                                let propName = element.propertyName || <Identifier>element.name;
+                                const propName = element.propertyName || <Identifier>element.name;
                                 emitBindingElement(element, createPropertyAccessForDestructuringProperty(value, propName));
                             }
                             else if (element.kind !== SyntaxKind.OmittedExpression) {
@@ -4312,7 +4304,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         // for (...) { var <some-uniqie-name> = void 0; }
                         // this is necessary to preserve ES6 semantic in scenarios like
                         // for (...) { let x; console.log(x); x = 1 } // assignment on one iteration should not affect other iterations
-                        let isLetDefinedInLoop =
+                        const isLetDefinedInLoop =
                             (resolver.getNodeCheckFlags(node) & NodeCheckFlags.BlockScopedBindingInLoop) &&
                             (getCombinedFlagsForIdentifier(<Identifier>node.name) & NodeFlags.Let);
 
@@ -4324,7 +4316,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         }
                     }
 
-                    let exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.name);
+                    const exportChanged = isNameOfExportedSourceLevelDeclarationInSystemExternalModule(node.name);
 
                     if (exportChanged) {
                         write(`${exportFunctionForFile}("`);
@@ -4345,7 +4337,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (node.kind === SyntaxKind.OmittedExpression) {
                     return;
                 }
-                let name = node.name;
+                const name = node.name;
                 if (name.kind === SyntaxKind.Identifier) {
                     emitExportMemberAssignments(<Identifier>name);
                 }
@@ -4387,7 +4379,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(";");
                 }
                 else {
-                    let atLeastOneItem = emitVariableDeclarationListSkippingUninitializedEntries(node.declarationList);
+                    const atLeastOneItem = emitVariableDeclarationListSkippingUninitializedEntries(node.declarationList);
                     if (atLeastOneItem) {
                         write(";");
                     }
@@ -4411,7 +4403,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 // Otherwise, only emit if we have at least one initializer present.
-                for (let declaration of node.declarationList.declarations) {
+                for (const declaration of node.declarationList.declarations) {
                     if (declaration.initializer) {
                         return true;
                     }
@@ -4422,7 +4414,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             function emitParameter(node: ParameterDeclaration) {
                 if (languageVersion < ScriptTarget.ES6) {
                     if (isBindingPattern(node.name)) {
-                        let name = createTempVariable(TempFlags.Auto);
+                        const name = createTempVariable(TempFlags.Auto);
                         if (!tempParameters) {
                             tempParameters = [];
                         }
@@ -4452,12 +4444,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             return;
                         }
 
-                        let { name: paramName, initializer } = parameter;
+                        const { name: paramName, initializer } = parameter;
                         if (isBindingPattern(paramName)) {
                             // In cases where a binding pattern is simply '[]' or '{}',
                             // we usually don't want to emit a var declaration; however, in the presence
                             // of an initializer, we must emit that expression to preserve side effects.
-                            let hasBindingElements = paramName.elements.length > 0;
+                            const hasBindingElements = paramName.elements.length > 0;
                             if (hasBindingElements || initializer) {
                                 writeLine();
                                 write("var ");
@@ -4496,15 +4488,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitRestParameter(node: FunctionLikeDeclaration) {
                 if (languageVersion < ScriptTarget.ES6 && hasRestParameter(node)) {
-                    let restIndex = node.parameters.length - 1;
-                    let restParam = node.parameters[restIndex];
+                    const restIndex = node.parameters.length - 1;
+                    const restParam = node.parameters[restIndex];
 
                     // A rest parameter cannot have a binding pattern, so let's just ignore it if it does.
                     if (isBindingPattern(restParam.name)) {
                         return;
                     }
 
-                    let tempName = createTempVariable(TempFlags._i).text;
+                    const tempName = createTempVariable(TempFlags._i).text;
                     writeLine();
                     emitLeadingComments(restParam);
                     emitStart(restParam);
@@ -4641,8 +4633,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 increaseIndent();
                 write("(");
                 if (node) {
-                    let parameters = node.parameters;
-                    let omitCount = languageVersion < ScriptTarget.ES6 && hasRestParameter(node) ? 1 : 0;
+                    const parameters = node.parameters;
+                    const omitCount = languageVersion < ScriptTarget.ES6 && hasRestParameter(node) ? 1 : 0;
                     emitList(parameters, 0, parameters.length - omitCount, /*multiLine*/ false, /*trailingComma*/ false);
                 }
                 write(")");
@@ -4660,10 +4652,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitAsyncFunctionBodyForES6(node: FunctionLikeDeclaration) {
-                let promiseConstructor = getEntityNameFromTypeNode(node.type);
-                let isArrowFunction = node.kind === SyntaxKind.ArrowFunction;
-                let hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0;
-                let args: string;
+                const promiseConstructor = getEntityNameFromTypeNode(node.type);
+                const isArrowFunction = node.kind === SyntaxKind.ArrowFunction;
+                const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0;
 
                 // An async function is emit as an outer function that calls an inner
                 // generator function. To preserve lexical bindings, we pass the current
@@ -4801,9 +4792,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitSignatureAndBody(node: FunctionLikeDeclaration) {
                 const saveConvertedLoopState = convertedLoopState;
-                let saveTempFlags = tempFlags;
-                let saveTempVariables = tempVariables;
-                let saveTempParameters = tempParameters;
+                const saveTempFlags = tempFlags;
+                const saveTempVariables = tempVariables;
+                const saveTempParameters = tempParameters;
 
                 convertedLoopState = undefined;
                 tempFlags = 0;
@@ -4819,7 +4810,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitSignatureParameters(node);
                 }
 
-                let isAsync = isAsyncFunctionLike(node);
+                const isAsync = isAsyncFunctionLike(node);
                 if (isAsync && languageVersion === ScriptTarget.ES6) {
                     emitAsyncFunctionBodyForES6(node);
                 }
@@ -4872,10 +4863,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 scopeEmitStart(node);
 
                 increaseIndent();
-                let outPos = writer.getTextPos();
-                emitDetachedComments(node.body);
+                const outPos = writer.getTextPos();
+                emitDetachedCommentsAndUpdateCommentsInfo(node.body);
                 emitFunctionBodyPreamble(node);
-                let preambleEmitted = writer.getTextPos() !== outPos;
+                const preambleEmitted = writer.getTextPos() !== outPos;
                 decreaseIndent();
 
                 // If we didn't have to emit any preamble code, then attempt to keep the arrow
@@ -4915,21 +4906,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(" {");
                 scopeEmitStart(node);
 
-                let initialTextPos = writer.getTextPos();
+                const initialTextPos = writer.getTextPos();
 
                 increaseIndent();
-                emitDetachedComments(body.statements);
+                emitDetachedCommentsAndUpdateCommentsInfo(body.statements);
 
                 // Emit all the directive prologues (like "use strict").  These have to come before
                 // any other preamble code we write (like parameter initializers).
-                let startIndex = emitDirectivePrologues(body.statements, /*startWithNewLine*/ true);
+                const startIndex = emitDirectivePrologues(body.statements, /*startWithNewLine*/ true);
                 emitFunctionBodyPreamble(node);
                 decreaseIndent();
 
-                let preambleEmitted = writer.getTextPos() !== initialTextPos;
+                const preambleEmitted = writer.getTextPos() !== initialTextPos;
 
                 if (!preambleEmitted && nodeEndIsOnSameLineAsNodeStart(body, body)) {
-                    for (let statement of body.statements) {
+                    for (const statement of body.statements) {
                         write(" ");
                         emit(statement);
                     }
@@ -4953,11 +4944,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function findInitialSuperCall(ctor: ConstructorDeclaration): ExpressionStatement {
                 if (ctor.body) {
-                    let statement = (<Block>ctor.body).statements[0];
+                    const statement = (<Block>ctor.body).statements[0];
                     if (statement && statement.kind === SyntaxKind.ExpressionStatement) {
-                        let expr = (<ExpressionStatement>statement).expression;
+                        const expr = (<ExpressionStatement>statement).expression;
                         if (expr && expr.kind === SyntaxKind.CallExpression) {
-                            let func = (<CallExpression>expr).expression;
+                            const func = (<CallExpression>expr).expression;
                             if (func && func.kind === SyntaxKind.SuperKeyword) {
                                 return <ExpressionStatement>statement;
                             }
@@ -5002,8 +4993,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function getInitializedProperties(node: ClassLikeDeclaration, isStatic: boolean) {
-                let properties: PropertyDeclaration[] = [];
-                for (let member of node.members) {
+                const properties: PropertyDeclaration[] = [];
+                for (const member of node.members) {
                     if (member.kind === SyntaxKind.PropertyDeclaration && isStatic === ((member.flags & NodeFlags.Static) !== 0) && (<PropertyDeclaration>member).initializer) {
                         properties.push(<PropertyDeclaration>member);
                     }
@@ -5013,7 +5004,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitPropertyDeclarations(node: ClassLikeDeclaration, properties: PropertyDeclaration[]) {
-                for (let property of properties) {
+                for (const property of properties) {
                     emitPropertyDeclaration(node, property);
                 }
             }
@@ -5071,7 +5062,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         emitTrailingComments(member);
                     }
                     else if (member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) {
-                        let accessors = getAllAccessorDeclarations(node.members, <AccessorDeclaration>member);
+                        const accessors = getAllAccessorDeclarations(node.members, <AccessorDeclaration>member);
                         if (member === accessors.firstAccessor) {
                             writeLine();
                             emitStart(member);
@@ -5119,7 +5110,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitMemberFunctionsForES6AndHigher(node: ClassLikeDeclaration) {
-                for (let member of node.members) {
+                for (const member of node.members) {
                     if ((member.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature) && !(<MethodDeclaration>member).body) {
                         emitCommentsOnNotEmittedNode(member);
                     }
@@ -5156,9 +5147,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitConstructor(node: ClassLikeDeclaration, baseTypeElement: ExpressionWithTypeArguments) {
                 const saveConvertedLoopState = convertedLoopState;
-                let saveTempFlags = tempFlags;
-                let saveTempVariables = tempVariables;
-                let saveTempParameters = tempParameters;
+                const saveTempFlags = tempFlags;
+                const saveTempVariables = tempVariables;
+                const saveTempParameters = tempParameters;
 
                 convertedLoopState = undefined;
                 tempFlags = 0;
@@ -5192,7 +5183,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 });
 
-                let ctor = getFirstConstructorWithBody(node);
+                const ctor = getFirstConstructorWithBody(node);
 
                 // For target ES6 and above, if there is no user-defined constructor and there is no property assignment
                 // do not emit constructor in class declaration.
@@ -5240,7 +5231,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     // Emit all the directive prologues (like "use strict").  These have to come before
                     // any other preamble code we write (like parameter initializers).
                     startIndex = emitDirectivePrologues(ctor.body.statements, /*startWithNewLine*/ true);
-                    emitDetachedComments(ctor.body.statements);
+                    emitDetachedCommentsAndUpdateCommentsInfo(ctor.body.statements);
                 }
                 emitCaptureThisForNodeIfNecessary(node);
                 let superCall: ExpressionStatement;
@@ -5312,7 +5303,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitClassLikeDeclarationForES6AndHigher(node: ClassLikeDeclaration) {
-                let thisNodeIsDecorated = nodeIsDecorated(node);
+                const thisNodeIsDecorated = nodeIsDecorated(node);
                 if (node.kind === SyntaxKind.ClassDeclaration) {
                     if (thisNodeIsDecorated) {
                         // To preserve the correct runtime semantics when decorators are applied to the class,
@@ -5391,8 +5382,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 //
                 // This keeps the expression as an expression, while ensuring that the static parts
                 // of it have been initialized by the time it is used.
-                let staticProperties = getInitializedProperties(node, /*static:*/ true);
-                let isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === SyntaxKind.ClassExpression;
+                const staticProperties = getInitializedProperties(node, /*static:*/ true);
+                const isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === SyntaxKind.ClassExpression;
                 let tempVariable: Identifier;
 
                 if (isClassExpressionWithStaticProperties) {
@@ -5413,7 +5404,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitDeclarationName(node);
                 }
 
-                let baseTypeNode = getClassExtendsHeritageClauseElement(node);
+                const baseTypeNode = getClassExtendsHeritageClauseElement(node);
                 if (baseTypeNode) {
                     write(" extends ");
                     emit(baseTypeNode.expression);
@@ -5498,16 +5489,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 write("(function (");
-                let baseTypeNode = getClassExtendsHeritageClauseElement(node);
+                const baseTypeNode = getClassExtendsHeritageClauseElement(node);
                 if (baseTypeNode) {
                     write("_super");
                 }
                 write(") {");
-                let saveTempFlags = tempFlags;
-                let saveTempVariables = tempVariables;
-                let saveTempParameters = tempParameters;
-                let saveComputedPropertyNamesToGeneratedNames = computedPropertyNamesToGeneratedNames;
-                let saveConvertedLoopState = convertedLoopState;
+                const saveTempFlags = tempFlags;
+                const saveTempVariables = tempVariables;
+                const saveTempParameters = tempParameters;
+                const saveComputedPropertyNamesToGeneratedNames = computedPropertyNamesToGeneratedNames;
+                const saveConvertedLoopState = convertedLoopState;
 
                 convertedLoopState = undefined;
                 tempFlags = 0;
@@ -5579,9 +5570,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitDecoratorsOfConstructor(node: ClassLikeDeclaration) {
-                let decorators = node.decorators;
-                let constructor = getFirstConstructorWithBody(node);
-                let hasDecoratedParameters = constructor && forEach(constructor.parameters, nodeIsDecorated);
+                const decorators = node.decorators;
+                const constructor = getFirstConstructorWithBody(node);
+                const hasDecoratedParameters = constructor && forEach(constructor.parameters, nodeIsDecorated);
 
                 // skip decoration of the constructor if neither it nor its parameters are decorated
                 if (!decorators && !hasDecoratedParameters) {
@@ -5606,7 +5597,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 increaseIndent();
                 writeLine();
 
-                let decoratorCount = decorators ? decorators.length : 0;
+                const decoratorCount = decorators ? decorators.length : 0;
                 let argumentsWritten = emitList(decorators, 0, decoratorCount, /*multiLine*/ true, /*trailingComma*/ false, /*leadingComma*/ false, /*noTrailingNewLine*/ true, decorator => {
                     emitStart(decorator);
                     emit(decorator.expression);
@@ -5626,7 +5617,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitDecoratorsOfMembers(node: ClassLikeDeclaration, staticFlag: NodeFlags) {
-                for (let member of node.members) {
+                for (const member of node.members) {
                     // only emit members in the correct group
                     if ((member.flags & NodeFlags.Static) !== staticFlag) {
                         continue;
@@ -5646,7 +5637,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     let decorators: NodeArray<Decorator>;
                     let functionLikeMember: FunctionLikeDeclaration;
                     if (isAccessor(member)) {
-                        let accessors = getAllAccessorDeclarations(node.members, <AccessorDeclaration>member);
+                        const accessors = getAllAccessorDeclarations(node.members, <AccessorDeclaration>member);
                         if (member !== accessors.firstAccessor) {
                             continue;
                         }
@@ -5706,7 +5697,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     increaseIndent();
                     writeLine();
 
-                    let decoratorCount = decorators ? decorators.length : 0;
+                    const decoratorCount = decorators ? decorators.length : 0;
                     let argumentsWritten = emitList(decorators, 0, decoratorCount, /*multiLine*/ true, /*trailingComma*/ false, /*leadingComma*/ false, /*noTrailingNewLine*/ true, decorator => {
                         emitStart(decorator);
                         emit(decorator.expression);
@@ -5748,9 +5739,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 let argumentsWritten = 0;
                 if (node) {
                     let parameterIndex = 0;
-                    for (let parameter of node.parameters) {
+                    for (const parameter of node.parameters) {
                         if (nodeIsDecorated(parameter)) {
-                            let decorators = parameter.decorators;
+                            const decorators = parameter.decorators;
                             argumentsWritten += emitList(decorators, 0, decorators.length, /*multiLine*/ true, /*trailingComma*/ false, /*leadingComma*/ leadingComma, /*noTrailingNewLine*/ true, decorator => {
                                 emitStart(decorator);
                                 write(`__param(${parameterIndex}, `);
@@ -5915,10 +5906,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 // Clone the type name and parent it to a location outside of the current declaration.
-                let typeName = cloneEntityName(node.typeName);
+                const typeName = cloneEntityName(node.typeName);
                 typeName.parent = location;
 
-                let result = resolver.getTypeReferenceSerializationKind(typeName);
+                const result = resolver.getTypeReferenceSerializationKind(typeName);
                 switch (result) {
                     case TypeReferenceSerializationKind.Unknown:
                         let temp = createAndRecordTempVariable(TempFlags.Auto);
@@ -6080,7 +6071,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function shouldEmitEnumDeclaration(node: EnumDeclaration) {
-                let isConstEnum = isConst(node);
+                const isConstEnum = isConst(node);
                 return !isConstEnum || compilerOptions.preserveConstEnums || compilerOptions.isolatedModules;
             }
 
@@ -6149,7 +6140,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitEnumMember(node: EnumMember) {
-                let enumParent = <EnumDeclaration>node.parent;
+                const enumParent = <EnumDeclaration>node.parent;
                 emitStart(node);
                 write(getGeneratedNameForNode(enumParent));
                 write("[");
@@ -6165,7 +6156,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function writeEnumMemberDeclarationValue(member: EnumMember) {
-                let value = resolver.getConstantValue(member);
+                const value = resolver.getConstantValue(member);
                 if (value !== undefined) {
                     write(value.toString());
                     return;
@@ -6180,7 +6171,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration: ModuleDeclaration): ModuleDeclaration {
                 if (moduleDeclaration.body.kind === SyntaxKind.ModuleDeclaration) {
-                    let recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(<ModuleDeclaration>moduleDeclaration.body);
+                    const recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(<ModuleDeclaration>moduleDeclaration.body);
                     return recursiveInnerModule || <ModuleDeclaration>moduleDeclaration.body;
                 }
             }
@@ -6195,13 +6186,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitModuleDeclaration(node: ModuleDeclaration) {
                 // Emit only if this module is non-ambient.
-                let shouldEmit = shouldEmitModuleDeclaration(node);
+                const shouldEmit = shouldEmitModuleDeclaration(node);
 
                 if (!shouldEmit) {
                     return emitCommentsOnNotEmittedNode(node);
                 }
-                let hoistedInDeclarationScope = shouldHoistDeclarationInSystemJsModule(node);
-                let emitVarForModule = !hoistedInDeclarationScope && !isModuleMergedWithES6Class(node);
+                const hoistedInDeclarationScope = shouldHoistDeclarationInSystemJsModule(node);
+                const emitVarForModule = !hoistedInDeclarationScope && !isModuleMergedWithES6Class(node);
 
                 if (emitVarForModule) {
                     emitStart(node);
@@ -6223,8 +6214,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(") ");
                 if (node.body.kind === SyntaxKind.ModuleBlock) {
                     const saveConvertedLoopState = convertedLoopState;
-                    let saveTempFlags = tempFlags;
-                    let saveTempVariables = tempVariables;
+                    const saveTempFlags = tempFlags;
+                    const saveTempVariables = tempVariables;
                     convertedLoopState = undefined;
                     tempFlags = 0;
                     tempVariables = undefined;
@@ -6246,7 +6237,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emit(node.body);
                     decreaseIndent();
                     writeLine();
-                    let moduleBlock = <ModuleBlock>getInnerMostModuleDeclarationFromDottedModule(node).body;
+                    const moduleBlock = <ModuleBlock>getInnerMostModuleDeclarationFromDottedModule(node).body;
                     emitToken(SyntaxKind.CloseBraceToken, moduleBlock.statements.end);
                     scopeEmitEnd();
                 }
@@ -6288,7 +6279,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             function emitRequire(moduleName: Expression) {
                 if (moduleName.kind === SyntaxKind.StringLiteral) {
                     write("require(");
-                    let text = tryRenameExternalModule(<LiteralExpression>moduleName);
+                    const text = tryRenameExternalModule(<LiteralExpression>moduleName);
                     if (text) {
                         write(text);
                     }
@@ -6308,7 +6299,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (node.kind === SyntaxKind.ImportEqualsDeclaration) {
                     return <ImportEqualsDeclaration>node;
                 }
-                let importClause = (<ImportDeclaration>node).importClause;
+                const importClause = (<ImportDeclaration>node).importClause;
                 if (importClause && importClause.namedBindings && importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
                     return <NamespaceImport>importClause.namedBindings;
                 }
@@ -6332,8 +6323,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 // ES6 import
                 if (node.importClause) {
-                    let shouldEmitDefaultBindings = resolver.isReferencedAliasDeclaration(node.importClause);
-                    let shouldEmitNamedBindings = node.importClause.namedBindings && resolver.isReferencedAliasDeclaration(node.importClause.namedBindings, /* checkChildren */ true);
+                    const shouldEmitDefaultBindings = resolver.isReferencedAliasDeclaration(node.importClause);
+                    const shouldEmitNamedBindings = node.importClause.namedBindings && resolver.isReferencedAliasDeclaration(node.importClause.namedBindings, /* checkChildren */ true);
                     if (shouldEmitDefaultBindings || shouldEmitNamedBindings) {
                         write("import ");
                         emitStart(node.importClause);
@@ -6374,8 +6365,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitExternalImportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration) {
                 if (contains(externalImports, node)) {
-                    let isExportedImport = node.kind === SyntaxKind.ImportEqualsDeclaration && (node.flags & NodeFlags.Export) !== 0;
-                    let namespaceDeclaration = getNamespaceDeclarationNode(node);
+                    const isExportedImport = node.kind === SyntaxKind.ImportEqualsDeclaration && (node.flags & NodeFlags.Export) !== 0;
+                    const namespaceDeclaration = getNamespaceDeclarationNode(node);
 
                     if (modulekind !== ModuleKind.AMD) {
                         emitLeadingComments(node);
@@ -6393,7 +6384,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             // import { x, y } from "foo"
                             // import d, * as x from "foo"
                             // import d, { x, y } from "foo"
-                            let isNakedImport = SyntaxKind.ImportDeclaration && !(<ImportDeclaration>node).importClause;
+                            const isNakedImport = SyntaxKind.ImportDeclaration && !(<ImportDeclaration>node).importClause;
                             if (!isNakedImport) {
                                 write("var ");
                                 write(getGeneratedNameForNode(<ImportDeclaration>node));
@@ -6448,11 +6439,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                     // variable declaration for import-equals declaration can be hoisted in system modules
                     // in this case 'var' should be omitted and emit should contain only initialization
-                    let variableDeclarationIsHoisted = shouldHoistVariable(node, /*checkIfSourceFileLevelDecl*/ true);
+                    const variableDeclarationIsHoisted = shouldHoistVariable(node, /*checkIfSourceFileLevelDecl*/ true);
 
                     // is it top level export import v = a.b.c in system module?
                     // if yes - it needs to be rewritten as exporter('v', v = a.b.c)
-                    let isExported = isSourceFileLevelDeclarationInSystemJsModule(node, /*isExported*/ true);
+                    const isExported = isSourceFileLevelDeclarationInSystemJsModule(node, /*isExported*/ true);
 
                     if (!variableDeclarationIsHoisted) {
                         Debug.assert(!isExported);
@@ -6494,7 +6485,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (modulekind !== ModuleKind.ES6) {
                     if (node.moduleSpecifier && (!node.exportClause || resolver.isValueAliasDeclaration(node))) {
                         emitStart(node);
-                        let generatedName = getGeneratedNameForNode(node);
+                        const generatedName = getGeneratedNameForNode(node);
                         if (node.exportClause) {
                             // export { x, y, ... } from "foo"
                             if (modulekind !== ModuleKind.AMD) {
@@ -6504,7 +6495,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                                 emitRequire(getExternalModuleName(node));
                                 write(";");
                             }
-                            for (let specifier of node.exportClause.elements) {
+                            for (const specifier of node.exportClause.elements) {
                                 if (resolver.isValueAliasDeclaration(specifier)) {
                                     writeLine();
                                     emitStart(specifier);
@@ -6560,7 +6551,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 Debug.assert(modulekind === ModuleKind.ES6);
 
                 let needsComma = false;
-                for (let specifier of specifiers) {
+                for (const specifier of specifiers) {
                     if (shouldEmit(specifier)) {
                         if (needsComma) {
                             write(", ");
@@ -6581,7 +6572,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         writeLine();
                         emitStart(node);
                         write("export default ");
-                        let expression = node.expression;
+                        const expression = node.expression;
                         emit(expression);
                         if (expression.kind !== SyntaxKind.FunctionDeclaration &&
                             expression.kind !== SyntaxKind.ClassDeclaration) {
@@ -6619,7 +6610,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 exportSpecifiers = {};
                 exportEquals = undefined;
                 hasExportStars = false;
-                for (let node of sourceFile.statements) {
+                for (const node of sourceFile.statements) {
                     switch (node.kind) {
                         case SyntaxKind.ImportDeclaration:
                             if (!(<ImportDeclaration>node).importClause ||
@@ -6651,8 +6642,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             }
                             else {
                                 // export { x, y }
-                                for (let specifier of (<ExportDeclaration>node).exportClause.elements) {
-                                    let name = (specifier.propertyName || specifier.name).text;
+                                for (const specifier of (<ExportDeclaration>node).exportClause.elements) {
+                                    const name = (specifier.propertyName || specifier.name).text;
                                     (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier);
                                 }
                             }
@@ -6681,7 +6672,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function getLocalNameForExternalImport(node: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration): string {
-                let namespaceDeclaration = getNamespaceDeclarationNode(node);
+                const namespaceDeclaration = getNamespaceDeclarationNode(node);
                 if (namespaceDeclaration && !isDefaultImport(node)) {
                     return getSourceTextOfNodeFromSourceFile(currentSourceFile, namespaceDeclaration.name);
                 }
@@ -6694,7 +6685,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function getExternalModuleNameText(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration): string {
-                let moduleName = getExternalModuleName(importNode);
+                const moduleName = getExternalModuleName(importNode);
                 if (moduleName.kind === SyntaxKind.StringLiteral) {
                     return tryRenameExternalModule(<LiteralExpression>moduleName) || getLiteralText(<LiteralExpression>moduleName);
                 }
@@ -6709,9 +6700,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 writeLine();
                 let started = false;
-                for (let importNode of externalImports) {
+                for (const importNode of externalImports) {
                     // do not create variable declaration for exports and imports that lack import clause
-                    let skipNode =
+                    const skipNode =
                         importNode.kind === SyntaxKind.ExportDeclaration ||
                         (importNode.kind === SyntaxKind.ImportDeclaration && !(<ImportDeclaration>importNode).importClause);
 
@@ -6750,7 +6741,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     // no exported declarations (export var ...) or export specifiers (export {x})
                     // check if we have any non star export declarations.
                     let hasExportDeclarationWithExportClause = false;
-                    for (let externalImport of externalImports) {
+                    for (const externalImport of externalImports) {
                         if (externalImport.kind === SyntaxKind.ExportDeclaration && (<ExportDeclaration>externalImport).exportClause) {
                             hasExportDeclarationWithExportClause = true;
                             break;
@@ -6778,26 +6769,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 if (exportSpecifiers) {
-                    for (let n in exportSpecifiers) {
-                        for (let specifier of exportSpecifiers[n]) {
+                    for (const n in exportSpecifiers) {
+                        for (const specifier of exportSpecifiers[n]) {
                             // write name of export specified, i.e. 'export {x}'
                             writeExportedName(specifier.name);
                         }
                     }
                 }
 
-                for (let externalImport of externalImports) {
+                for (const externalImport of externalImports) {
                     if (externalImport.kind !== SyntaxKind.ExportDeclaration) {
                         continue;
                     }
 
-                    let exportDecl = <ExportDeclaration>externalImport;
+                    const exportDecl = <ExportDeclaration>externalImport;
                     if (!exportDecl.exportClause) {
                         // export * from ...
                         continue;
                     }
 
-                    for (let element of exportDecl.exportClause.elements) {
+                    for (const element of exportDecl.exportClause.elements) {
                         // write name of indirectly exported entry, i.e. 'export {x} from ...'
                         writeExportedName(element.name || element.propertyName);
                     }
@@ -6886,16 +6877,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (hoistedVars) {
                     writeLine();
                     write("var ");
-                    let seen: Map<string> = {};
+                    const seen: Map<string> = {};
                     for (let i = 0; i < hoistedVars.length; ++i) {
-                        let local = hoistedVars[i];
-                        let name = local.kind === SyntaxKind.Identifier
+                        const local = hoistedVars[i];
+                        const name = local.kind === SyntaxKind.Identifier
                             ? <Identifier>local
                             : <Identifier>(<ClassDeclaration | ModuleDeclaration | EnumDeclaration>local).name;
 
                         if (name) {
                             // do not emit duplicate entries (in case of declaration merging) in the list of hoisted variables
-                            let text = unescapeIdentifier(name.text);
+                            const text = unescapeIdentifier(name.text);
                             if (hasProperty(seen, text)) {
                                 continue;
                             }
@@ -6915,7 +6906,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             emit(local);
                         }
 
-                        let flags = getCombinedNodeFlags(local.kind === SyntaxKind.Identifier ? local.parent : local);
+                        const flags = getCombinedNodeFlags(local.kind === SyntaxKind.Identifier ? local.parent : local);
                         if (flags & NodeFlags.Export) {
                             if (!exportedDeclarations) {
                                 exportedDeclarations = [];
@@ -6927,7 +6918,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 if (hoistedFunctionDeclarations) {
-                    for (let f of hoistedFunctionDeclarations) {
+                    for (const f of hoistedFunctionDeclarations) {
                         writeLine();
                         emit(f);
 
@@ -6990,7 +6981,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                     if (node.kind === SyntaxKind.VariableDeclaration || node.kind === SyntaxKind.BindingElement) {
                         if (shouldHoistVariable(<VariableDeclaration | BindingElement>node, /*checkIfSourceFileLevelDecl*/ false)) {
-                            let name = (<VariableDeclaration | BindingElement>node).name;
+                            const name = (<VariableDeclaration | BindingElement>node).name;
                             if (name.kind === SyntaxKind.Identifier) {
                                 if (!hoistedVars) {
                                     hoistedVars = [];
@@ -7081,8 +7072,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // }
                 emitVariableDeclarationsForImports();
                 writeLine();
-                let exportedDeclarations = processTopLevelVariableAndFunctionDeclarations(node);
-                let exportStarFunction = emitLocalStorageForExportedNamesIfNecessary(exportedDeclarations);
+                const exportedDeclarations = processTopLevelVariableAndFunctionDeclarations(node);
+                const exportStarFunction = emitLocalStorageForExportedNamesIfNecessary(exportedDeclarations);
                 writeLine();
                 write("return {");
                 increaseIndent();
@@ -7107,15 +7098,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     writeLine();
                     increaseIndent();
 
-                    let group = dependencyGroups[i];
+                    const group = dependencyGroups[i];
 
                     // derive a unique name for parameter from the first named entry in the group
-                    let parameterName = makeUniqueName(forEach(group, getLocalNameForExternalImport) || "");
+                    const parameterName = makeUniqueName(forEach(group, getLocalNameForExternalImport) || "");
                     write(`function (${parameterName}) {`);
                     increaseIndent();
 
-                    for (let entry of group) {
-                        let importVariableName = getLocalNameForExternalImport(entry) || "";
+                    for (const entry of group) {
+                        const importVariableName = getLocalNameForExternalImport(entry) || "";
 
                         switch (entry.kind) {
                             case SyntaxKind.ImportDeclaration:
@@ -7153,7 +7144,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                                             writeLine();
                                         }
 
-                                        let e = (<ExportDeclaration>entry).exportClause.elements[i];
+                                        const e = (<ExportDeclaration>entry).exportClause.elements[i];
                                         write(`"`);
                                         emitNodeWithCommentsAndWithoutSourcemap(e.name);
                                         write(`": ${parameterName}["`);
@@ -7191,7 +7182,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 increaseIndent();
                 writeLine();
                 for (let i = startIndex; i < node.statements.length; ++i) {
-                    let statement = node.statements[i];
+                    const statement = node.statements[i];
                     switch (statement.kind) {
                         // - function declarations are not emitted because they were already hoisted
                         // - import declarations are not emitted since they are already handled in setters
@@ -7202,7 +7193,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             continue;
                         case SyntaxKind.ExportDeclaration:
                             if (!(<ExportDeclaration>statement).moduleSpecifier) {
-                                for (let element of (<ExportDeclaration>statement).exportClause.elements) {
+                                for (const element of (<ExportDeclaration>statement).exportClause.elements) {
                                     // write call to exporter function for every export specifier in exports list
                                     emitExportSpecifierInSystemModule(element);
                                 }
@@ -7244,14 +7235,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 write("[");
 
-                let groupIndices: Map<number> = {};
-                let dependencyGroups: DependencyGroup[] = [];
+                const groupIndices: Map<number> = {};
+                const dependencyGroups: DependencyGroup[] = [];
 
                 for (let i = 0; i < externalImports.length; ++i) {
-                    let text = getExternalModuleNameText(externalImports[i]);
+                    const text = getExternalModuleNameText(externalImports[i]);
                     if (hasProperty(groupIndices, text)) {
                         // deduplicate/group entries in dependency list by the dependency name
-                        let groupIndex = groupIndices[text];
+                        const groupIndex = groupIndices[text];
                         dependencyGroups[groupIndex].push(externalImports[i]);
                         continue;
                     }
@@ -7269,7 +7260,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(`], function(${exportFunctionForFile}) {`);
                 writeLine();
                 increaseIndent();
-                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
+                const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
                 emitEmitHelpers(node);
                 emitCaptureThisForNodeIfNecessary(node);
                 emitSystemModuleBody(node, dependencyGroups, startIndex);
@@ -7286,15 +7277,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function getAMDDependencyNames(node: SourceFile, includeNonAmdDependencies: boolean): AMDDependencyNames {
                 // names of modules with corresponding parameter in the factory function
-                let aliasedModuleNames: string[] = [];
+                const aliasedModuleNames: string[] = [];
                 // names of modules with no corresponding parameters in factory function
-                let unaliasedModuleNames: string[] = [];
-                let importAliasNames: string[] = [];     // names of the parameters in the factory function; these
+                const unaliasedModuleNames: string[] = [];
+                const importAliasNames: string[] = [];     // names of the parameters in the factory function; these
                 // parameters need to match the indexes of the corresponding
                 // module names in aliasedModuleNames.
 
                 // Fill in amd-dependency tags
-                for (let amdDependency of node.amdDependencies) {
+                for (const amdDependency of node.amdDependencies) {
                     if (amdDependency.name) {
                         aliasedModuleNames.push("\"" + amdDependency.path + "\"");
                         importAliasNames.push(amdDependency.name);
@@ -7304,12 +7295,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 }
 
-                for (let importNode of externalImports) {
+                for (const importNode of externalImports) {
                     // Find the name of the external module
-                    let externalModuleName = getExternalModuleNameText(importNode);
+                    const externalModuleName = getExternalModuleNameText(importNode);
 
                     // Find the name of the module alias, if there is one
-                    let importAliasName = getLocalNameForExternalImport(importNode);
+                    const importAliasName = getLocalNameForExternalImport(importNode);
                     if (includeNonAmdDependencies && importAliasName) {
                         aliasedModuleNames.push(externalModuleName);
                         importAliasNames.push(importAliasName);
@@ -7335,7 +7326,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // `import "module"` or `<amd-dependency path= "a.css" />`
                 // we need to add modules without alias names to the end of the dependencies list
 
-                let dependencyNames = getAMDDependencyNames(node, includeNonAmdDependencies);
+                const dependencyNames = getAMDDependencyNames(node, includeNonAmdDependencies);
                 emitAMDDependencyList(dependencyNames);
                 write(", ");
                 emitAMDFactoryHeader(dependencyNames);
@@ -7374,7 +7365,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 emitAMDDependencies(node, /*includeNonAmdDependencies*/ true);
                 increaseIndent();
-                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
+                const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
                 emitExportStarHelper();
                 emitCaptureThisForNodeIfNecessary(node);
                 emitLinesStartingAt(node.statements, startIndex);
@@ -7386,7 +7377,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitCommonJSModule(node: SourceFile) {
-                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
+                const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                 emitEmitHelpers(node);
                 collectExternalModuleInfo(node);
                 emitExportStarHelper();
@@ -7400,7 +7391,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitEmitHelpers(node);
                 collectExternalModuleInfo(node);
 
-                let dependencyNames = getAMDDependencyNames(node, /*includeNonAmdDependencies*/ false);
+                const dependencyNames = getAMDDependencyNames(node, /*includeNonAmdDependencies*/ false);
 
                 // Module is detected first to support Browserify users that load into a browser with an AMD loader
                 writeLines(`(function (factory) {
@@ -7415,7 +7406,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 })(`);
                 emitAMDFactoryHeader(dependencyNames);
                 increaseIndent();
-                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
+                const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true);
                 emitExportStarHelper();
                 emitCaptureThisForNodeIfNecessary(node);
                 emitLinesStartingAt(node.statements, startIndex);
@@ -7431,7 +7422,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 exportSpecifiers = undefined;
                 exportEquals = undefined;
                 hasExportStars = false;
-                let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
+                const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                 emitEmitHelpers(node);
                 emitCaptureThisForNodeIfNecessary(node);
                 emitLinesStartingAt(node.statements, startIndex);
@@ -7466,7 +7457,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function trimReactWhitespaceAndApplyEntities(node: JsxText): string {
                 let result: string = undefined;
-                let text = getTextOfNode(node, /*includeTrivia*/ true);
+                const text = getTextOfNode(node, /*includeTrivia*/ true);
                 let firstNonWhitespace = 0;
                 let lastNonWhitespace = -1;
 
@@ -7474,10 +7465,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // start/end of a tag is considered a start/end of a line only if that line is
                 // on the same line as the closing tag. See examples in tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx
                 for (let i = 0; i < text.length; i++) {
-                    let c = text.charCodeAt(i);
+                    const c = text.charCodeAt(i);
                     if (isLineBreak(c)) {
                         if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) {
-                            let part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1);
+                            const part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1);
                             result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part);
                         }
                         firstNonWhitespace = -1;
@@ -7491,7 +7482,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 if (firstNonWhitespace !== -1) {
-                    let part = text.substr(firstNonWhitespace);
+                    const part = text.substr(firstNonWhitespace);
                     result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part);
                 }
 
@@ -7574,9 +7565,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function writeLines(text: string): void {
-                let lines = text.split(/\r\n|\r|\n/g);
+                const lines = text.split(/\r\n|\r|\n/g);
                 for (let i = 0; i < lines.length; ++i) {
-                    let line = lines[i];
+                    const line = lines[i];
                     if (line.length) {
                         writeLine();
                         write(line);
@@ -7618,15 +7609,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 // Start new file on new line
                 writeLine();
                 emitShebang();
-                emitDetachedComments(node);
+                emitDetachedCommentsAndUpdateCommentsInfo(node);
 
                 if (isExternalModule(node) || compilerOptions.isolatedModules) {
-                    let emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[ModuleKind.CommonJS];
+                    const emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[ModuleKind.CommonJS];
                     emitModule(node);
                 }
                 else {
                     // emit prologue directives prior to __extends
-                    let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
+                    const startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false);
                     externalImports = undefined;
                     exportSpecifiers = undefined;
                     exportEquals = undefined;
@@ -7655,7 +7646,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         return emitNodeWithoutSourceMap(node);
                     }
 
-                    let emitComments = shouldEmitLeadingAndTrailingComments(node);
+                    const emitComments = shouldEmitLeadingAndTrailingComments(node);
                     if (emitComments) {
                         emitLeadingComments(node);
                     }
@@ -7902,7 +7893,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function getLeadingCommentsWithoutDetachedComments() {
                 // get the leading comments from detachedPos
-                let leadingComments = getLeadingCommentRanges(currentSourceFile.text,
+                const leadingComments = getLeadingCommentRanges(currentSourceFile.text,
                     lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos);
                 if (detachedCommentsInfo.length - 1) {
                     detachedCommentsInfo.pop();
@@ -7914,11 +7905,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 return leadingComments;
             }
 
-            function isPinnedComments(comment: CommentRange) {
-                return currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
-                    currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation;
-            }
-
             /**
              * Determine if the given comment is a triple-slash
              *
@@ -7930,7 +7916,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.slash &&
                     comment.pos + 2 < comment.end &&
                     currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.slash) {
-                    let textSubStr = currentSourceFile.text.substring(comment.pos, comment.end);
+                    const textSubStr = currentSourceFile.text.substring(comment.pos, comment.end);
                     return textSubStr.match(fullTripleSlashReferencePathRegEx) ||
                         textSubStr.match(fullTripleSlashAMDReferencePathRegEx) ?
                         true : false;
@@ -8009,7 +7995,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
 
                 // Emit the trailing comments only if the parent's end doesn't match
-                let trailingComments = getTrailingCommentsToEmit(node);
+                const trailingComments = getTrailingCommentsToEmit(node);
 
                 // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
                 emitComments(currentSourceFile, writer, trailingComments, /*trailingSeparator*/ false, newLine, writeComment);
@@ -8025,7 +8011,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     return;
                 }
 
-                let trailingComments = getTrailingCommentRanges(currentSourceFile.text, pos);
+                const trailingComments = getTrailingCommentRanges(currentSourceFile.text, pos);
 
                 // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment*/
                 emitComments(currentSourceFile, writer, trailingComments, /*trailingSeparator*/ true, newLine, writeComment);
@@ -8052,68 +8038,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitComments(currentSourceFile, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
             }
 
-            function emitDetachedComments(node: TextRange) {
-                let leadingComments: CommentRange[];
-                if (compilerOptions.removeComments) {
-                    // removeComments is true, only reserve pinned comment at the top of file
-                    // For example:
-                    //      /*! Pinned Comment */
-                    //
-                    //      var x = 10;
-                    if (node.pos === 0) {
-                        leadingComments = filter(getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComments);
+            function emitDetachedCommentsAndUpdateCommentsInfo(node: TextRange) {
+                const currentDetachedCommentInfo = emitDetachedComments(currentSourceFile, writer, writeComment, node, newLine, compilerOptions.removeComments);
+
+                if (currentDetachedCommentInfo) {
+                    if (detachedCommentsInfo) {
+                        detachedCommentsInfo.push(currentDetachedCommentInfo);
                     }
-                }
-                else {
-                    // removeComments is false, just get detached as normal and bypass the process to filter comment
-                    leadingComments = getLeadingCommentRanges(currentSourceFile.text, node.pos);
-                }
-
-                if (leadingComments) {
-                    let detachedComments: CommentRange[] = [];
-                    let lastComment: CommentRange;
-
-                    forEach(leadingComments, comment => {
-                        if (lastComment) {
-                            let lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end);
-                            let commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos);
-
-                            if (commentLine >= lastCommentLine + 2) {
-                                // There was a blank line between the last comment and this comment.  This
-                                // comment is not part of the copyright comments.  Return what we have so
-                                // far.
-                                return detachedComments;
-                            }
-                        }
-
-                        detachedComments.push(comment);
-                        lastComment = comment;
-                    });
-
-                    if (detachedComments.length) {
-                        // All comments look like they could have been part of the copyright header.  Make
-                        // sure there is at least one blank line between it and the node.  If not, it's not
-                        // a copyright header.
-                        let lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastOrUndefined(detachedComments).end);
-                        let nodeLine = getLineOfLocalPosition(currentSourceFile, skipTrivia(currentSourceFile.text, node.pos));
-                        if (nodeLine >= lastCommentLine + 2) {
-                            // Valid detachedComments
-                            emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
-                            emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
-                            let currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: lastOrUndefined(detachedComments).end };
-                            if (detachedCommentsInfo) {
-                                detachedCommentsInfo.push(currentDetachedCommentInfo);
-                            }
-                            else {
-                                detachedCommentsInfo = [currentDetachedCommentInfo];
-                            }
-                        }
+                    else {
+                        detachedCommentsInfo = [currentDetachedCommentInfo];
                     }
                 }
             }
 
             function emitShebang() {
-                let shebang = getShebang(currentSourceFile.text);
+                const shebang = getShebang(currentSourceFile.text);
                 if (shebang) {
                     write(shebang);
                 }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 01fd0c20963..4a8d97a3dfb 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -2,7 +2,7 @@
 /// <reference path="utilities.ts"/>
 
 namespace ts {
-    let nodeConstructors = new Array<new (pos: number, end: number) => Node>(SyntaxKind.Count);
+    const nodeConstructors = new Array<new (pos: number, end: number) => Node>(SyntaxKind.Count);
     /* @internal */ export let parseTime = 0;
 
     export function getNodeConstructor(kind: SyntaxKind): new (pos?: number, end?: number) => Node {
@@ -27,8 +27,8 @@ namespace ts {
 
     function visitEachNode<T>(cbNode: (node: Node) => T, nodes: Node[]) {
         if (nodes) {
-            for (let node of nodes) {
-                let result = cbNode(node);
+            for (const node of nodes) {
+                const result = cbNode(node);
                 if (result) {
                     return result;
                 }
@@ -47,8 +47,8 @@ namespace ts {
         // The visitXXX functions could be written as local functions that close over the cbNode and cbNodeArray
         // callback parameters, but that causes a closure allocation for each invocation with noticeable effects
         // on performance.
-        let visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;
-        let cbNodes = cbNodeArray || cbNode;
+        const visitNodes: (cb: (node: Node | Node[]) => T, nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;
+        const cbNodes = cbNodeArray || cbNode;
         switch (node.kind) {
             case SyntaxKind.QualifiedName:
                 return visitNode(cbNode, (<QualifiedName>node).left) ||
@@ -397,8 +397,8 @@ namespace ts {
     }
 
     export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false): SourceFile {
-        let start = new Date().getTime();
-        let result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes);
+        const start = new Date().getTime();
+        const result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes);
 
         parseTime += new Date().getTime() - start;
         return result;
@@ -529,7 +529,7 @@ namespace ts {
         export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean): SourceFile {
             initializeState(fileName, _sourceText, languageVersion, _syntaxCursor);
 
-            let result = parseSourceFileWorker(fileName, languageVersion, setParentNodes);
+            const result = parseSourceFileWorker(fileName, languageVersion, setParentNodes);
 
             clearState();
 
@@ -625,10 +625,10 @@ namespace ts {
         }
 
         function addJSDocComment(node: Node) {
-            let comments = getLeadingCommentRangesOfNode(node, sourceFile);
+            const comments = getLeadingCommentRangesOfNode(node, sourceFile);
             if (comments) {
-                for (let comment of comments) {
-                    let jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
+                for (const comment of comments) {
+                    const jsDocComment = JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos);
                     if (jsDocComment) {
                         node.jsDocComment = jsDocComment;
                     }
@@ -653,7 +653,7 @@ namespace ts {
                 if (n.parent !== parent) {
                     n.parent = parent;
 
-                    let saveParent = parent;
+                    const saveParent = parent;
                     parent = n;
                     forEachChild(n, visitNode);
                     parent = saveParent;
@@ -662,7 +662,7 @@ namespace ts {
         }
 
         function createSourceFile(fileName: string, languageVersion: ScriptTarget): SourceFile {
-            let sourceFile = <SourceFile>createNode(SyntaxKind.SourceFile, /*pos*/ 0);
+            const sourceFile = <SourceFile>createNode(SyntaxKind.SourceFile, /*pos*/ 0);
 
             sourceFile.pos = 0;
             sourceFile.end = sourceText.length;
@@ -708,11 +708,11 @@ namespace ts {
             // that we do not mutate cached flags for the incremental
             // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and
             // HasAggregatedChildData).
-            let contextFlagsToClear = context & contextFlags;
+            const contextFlagsToClear = context & contextFlags;
             if (contextFlagsToClear) {
                 // clear the requested context flags
                 setContextFlag(false, contextFlagsToClear);
-                let result = func();
+                const result = func();
                 // restore the context flags we just cleared
                 setContextFlag(true, contextFlagsToClear);
                 return result;
@@ -729,11 +729,11 @@ namespace ts {
             // that we do not mutate cached flags for the incremental
             // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and
             // HasAggregatedChildData).
-            let contextFlagsToSet = context & ~contextFlags;
+            const contextFlagsToSet = context & ~contextFlags;
             if (contextFlagsToSet) {
                 // set the requested context flags
                 setContextFlag(true, contextFlagsToSet);
-                let result = func();
+                const result = func();
                 // reset the context flags we just set
                 setContextFlag(false, contextFlagsToSet);
                 return result;
@@ -800,15 +800,15 @@ namespace ts {
         }
 
         function parseErrorAtCurrentToken(message: DiagnosticMessage, arg0?: any): void {
-            let start = scanner.getTokenPos();
-            let length = scanner.getTextPos() - start;
+            const start = scanner.getTokenPos();
+            const length = scanner.getTextPos() - start;
 
             parseErrorAtPosition(start, length, message, arg0);
         }
 
         function parseErrorAtPosition(start: number, length: number, message: DiagnosticMessage, arg0?: any): void {
             // Don't report another error if it would just be at the same position as the last error.
-            let lastError = lastOrUndefined(parseDiagnostics);
+            const lastError = lastOrUndefined(parseDiagnostics);
             if (!lastError || start !== lastError.start) {
                 parseDiagnostics.push(createFileDiagnostic(sourceFile, start, length, message, arg0));
             }
@@ -819,7 +819,7 @@ namespace ts {
         }
 
         function scanError(message: DiagnosticMessage, length?: number) {
-            let pos = scanner.getTextPos();
+            const pos = scanner.getTextPos();
             parseErrorAtPosition(pos, length || 0, message);
         }
 
@@ -862,20 +862,20 @@ namespace ts {
         function speculationHelper<T>(callback: () => T, isLookAhead: boolean): T {
             // Keep track of the state we'll need to rollback to if lookahead fails (or if the
             // caller asked us to always reset our state).
-            let saveToken = token;
-            let saveParseDiagnosticsLength = parseDiagnostics.length;
-            let saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
+            const saveToken = token;
+            const saveParseDiagnosticsLength = parseDiagnostics.length;
+            const saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
 
             // Note: it is not actually necessary to save/restore the context flags here.  That's
             // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
             // assert that that invariant holds.
-            let saveContextFlags = contextFlags;
+            const saveContextFlags = contextFlags;
 
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
             // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the
             // same.
-            let result = isLookAhead
+            const result = isLookAhead
                 ? scanner.lookAhead(callback)
                 : scanner.tryScan(callback);
 
@@ -967,7 +967,7 @@ namespace ts {
         }
 
         function parseTokenNode<T extends Node>(): T {
-            let node = <T>createNode(token);
+            const node = <T>createNode(token);
             nextToken();
             return finishNode(node);
         }
@@ -1030,7 +1030,7 @@ namespace ts {
                 parseErrorAtCurrentToken(diagnosticMessage, arg0);
             }
 
-            let result = createNode(kind, scanner.getStartPos());
+            const result = createNode(kind, scanner.getStartPos());
             (<Identifier>result).text = "";
             return finishNode(result);
         }
@@ -1046,7 +1046,7 @@ namespace ts {
         function createIdentifier(isIdentifier: boolean, diagnosticMessage?: DiagnosticMessage): Identifier {
             identifierCount++;
             if (isIdentifier) {
-                let node = <Identifier>createNode(SyntaxKind.Identifier);
+                const node = <Identifier>createNode(SyntaxKind.Identifier);
 
                 // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker
                 if (token !== SyntaxKind.Identifier) {
@@ -1100,7 +1100,7 @@ namespace ts {
             // PropertyName [Yield]:
             //      LiteralPropertyName
             //      ComputedPropertyName[?Yield]
-            let node = <ComputedPropertyName>createNode(SyntaxKind.ComputedPropertyName);
+            const node = <ComputedPropertyName>createNode(SyntaxKind.ComputedPropertyName);
             parseExpected(SyntaxKind.OpenBracketToken);
 
             // We parse any expression (including a comma expression). But the grammar
@@ -1161,7 +1161,7 @@ namespace ts {
 
         // True if positioned at the start of a list element
         function isListElement(parsingContext: ParsingContext, inErrorRecovery: boolean): boolean {
-            let node = currentNode(parsingContext);
+            const node = currentNode(parsingContext);
             if (node) {
                 return true;
             }
@@ -1255,7 +1255,7 @@ namespace ts {
                 //      extends {} extends
                 //      extends {} implements
 
-                let next = nextToken();
+                const next = nextToken();
                 return next === SyntaxKind.CommaToken || next === SyntaxKind.OpenBraceToken || next === SyntaxKind.ExtendsKeyword || next === SyntaxKind.ImplementsKeyword;
             }
 
@@ -1383,14 +1383,14 @@ namespace ts {
 
         // Parses a list of elements
         function parseList<T extends Node>(kind: ParsingContext, parseElement: () => T): NodeArray<T> {
-            let saveParsingContext = parsingContext;
+            const saveParsingContext = parsingContext;
             parsingContext |= 1 << kind;
-            let result = <NodeArray<T>>[];
+            const result = <NodeArray<T>>[];
             result.pos = getNodePos();
 
             while (!isListTerminator(kind)) {
                 if (isListElement(kind, /* inErrorRecovery */ false)) {
-                    let element = parseListElement(kind, parseElement);
+                    const element = parseListElement(kind, parseElement);
                     result.push(element);
 
                     continue;
@@ -1407,7 +1407,7 @@ namespace ts {
         }
 
         function parseListElement<T extends Node>(parsingContext: ParsingContext, parseElement: () => T): T {
-            let node = currentNode(parsingContext);
+            const node = currentNode(parsingContext);
             if (node) {
                 return <T>consumeNode(node);
             }
@@ -1432,7 +1432,7 @@ namespace ts {
                 return undefined;
             }
 
-            let node = syntaxCursor.currentNode(scanner.getStartPos());
+            const node = syntaxCursor.currentNode(scanner.getStartPos());
 
             // Can't reuse a missing node.
             if (nodeIsMissing(node)) {
@@ -1461,7 +1461,7 @@ namespace ts {
             // differently depending on what mode it is in.
             //
             // This also applies to all our other context flags as well.
-            let nodeContextFlags = node.parserContextFlags & ParserContextFlags.ParserGeneratedFlags;
+            const nodeContextFlags = node.parserContextFlags & ParserContextFlags.ParserGeneratedFlags;
             if (nodeContextFlags !== contextFlags) {
                 return undefined;
             }
@@ -1673,7 +1673,7 @@ namespace ts {
             //
             // In order to prevent this, we do not allow a variable declarator to be reused if it
             // has an initializer.
-            let variableDeclarator = <VariableDeclaration>node;
+            const variableDeclarator = <VariableDeclaration>node;
             return variableDeclarator.initializer === undefined;
         }
 
@@ -1683,7 +1683,7 @@ namespace ts {
             }
 
             // See the comment in isReusableVariableDeclaration for why we do this.
-            let parameter = <ParameterDeclaration>node;
+            const parameter = <ParameterDeclaration>node;
             return parameter.initializer === undefined;
         }
 
@@ -1731,9 +1731,9 @@ namespace ts {
 
         // Parses a comma-delimited list of elements
         function parseDelimitedList<T extends Node>(kind: ParsingContext, parseElement: () => T, considerSemicolonAsDelimeter?: boolean): NodeArray<T> {
-            let saveParsingContext = parsingContext;
+            const saveParsingContext = parsingContext;
             parsingContext |= 1 << kind;
-            let result = <NodeArray<T>>[];
+            const result = <NodeArray<T>>[];
             result.pos = getNodePos();
 
             let commaStart = -1; // Meaning the previous token was not a comma
@@ -1790,8 +1790,8 @@ namespace ts {
         }
 
         function createMissingList<T>(): NodeArray<T> {
-            let pos = getNodePos();
-            let result = <NodeArray<T>>[];
+            const pos = getNodePos();
+            const result = <NodeArray<T>>[];
             result.pos = pos;
             result.end = pos;
             return result;
@@ -1799,7 +1799,7 @@ namespace ts {
 
         function parseBracketedList<T extends Node>(kind: ParsingContext, parseElement: () => T, open: SyntaxKind, close: SyntaxKind): NodeArray<T> {
             if (parseExpected(open)) {
-                let result = parseDelimitedList(kind, parseElement);
+                const result = parseDelimitedList(kind, parseElement);
                 parseExpected(close);
                 return result;
             }
@@ -1811,7 +1811,7 @@ namespace ts {
         function parseEntityName(allowReservedWords: boolean, diagnosticMessage?: DiagnosticMessage): EntityName {
             let entity: EntityName = parseIdentifier(diagnosticMessage);
             while (parseOptional(SyntaxKind.DotToken)) {
-                let node = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
+                const node = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
                 node.left = entity;
                 node.right = parseRightSideOfDot(allowReservedWords);
                 entity = finishNode(node);
@@ -1840,7 +1840,7 @@ namespace ts {
             // In the first case though, ASI will not take effect because there is not a
             // line terminator after the identifier or keyword.
             if (scanner.hasPrecedingLineBreak() && tokenIsIdentifierOrKeyword(token)) {
-                let matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
+                const matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
 
                 if (matchesPattern) {
                     // Report that we need an identifier.  However, report it right after the dot,
@@ -1854,12 +1854,12 @@ namespace ts {
         }
 
         function parseTemplateExpression(): TemplateExpression {
-            let template = <TemplateExpression>createNode(SyntaxKind.TemplateExpression);
+            const template = <TemplateExpression>createNode(SyntaxKind.TemplateExpression);
 
             template.head = parseLiteralNode();
             Debug.assert(template.head.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
 
-            let templateSpans = <NodeArray<TemplateSpan>>[];
+            const templateSpans = <NodeArray<TemplateSpan>>[];
             templateSpans.pos = getNodePos();
 
             do {
@@ -1874,7 +1874,7 @@ namespace ts {
         }
 
         function parseTemplateSpan(): TemplateSpan {
-            let span = <TemplateSpan>createNode(SyntaxKind.TemplateSpan);
+            const span = <TemplateSpan>createNode(SyntaxKind.TemplateSpan);
             span.expression = allowInAnd(parseExpression);
 
             let literal: LiteralExpression;
@@ -1892,8 +1892,8 @@ namespace ts {
         }
 
         function parseLiteralNode(internName?: boolean): LiteralExpression {
-            let node = <LiteralExpression>createNode(token);
-            let text = scanner.getTokenValue();
+            const node = <LiteralExpression>createNode(token);
+            const text = scanner.getTokenValue();
             node.text = internName ? internIdentifier(text) : text;
 
             if (scanner.hasExtendedUnicodeEscape()) {
@@ -1904,7 +1904,7 @@ namespace ts {
                 node.isUnterminated = true;
             }
 
-            let tokenPos = scanner.getTokenPos();
+            const tokenPos = scanner.getTokenPos();
             nextToken();
             finishNode(node);
 
@@ -1927,15 +1927,15 @@ namespace ts {
         // TYPES
 
         function parseTypeReferenceOrTypePredicate(): TypeReferenceNode | TypePredicateNode {
-            let typeName = parseEntityName(/*allowReservedWords*/ false, Diagnostics.Type_expected);
+            const typeName = parseEntityName(/*allowReservedWords*/ false, Diagnostics.Type_expected);
             if (typeName.kind === SyntaxKind.Identifier && token === SyntaxKind.IsKeyword && !scanner.hasPrecedingLineBreak()) {
                 nextToken();
-                let node = <TypePredicateNode>createNode(SyntaxKind.TypePredicate, typeName.pos);
+                const node = <TypePredicateNode>createNode(SyntaxKind.TypePredicate, typeName.pos);
                 node.parameterName = <Identifier>typeName;
                 node.type = parseType();
                 return finishNode(node);
             }
-            let node = <TypeReferenceNode>createNode(SyntaxKind.TypeReference, typeName.pos);
+            const node = <TypeReferenceNode>createNode(SyntaxKind.TypeReference, typeName.pos);
             node.typeName = typeName;
             if (!scanner.hasPrecedingLineBreak() && token === SyntaxKind.LessThanToken) {
                 node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);
@@ -1944,14 +1944,14 @@ namespace ts {
         }
 
         function parseTypeQuery(): TypeQueryNode {
-            let node = <TypeQueryNode>createNode(SyntaxKind.TypeQuery);
+            const node = <TypeQueryNode>createNode(SyntaxKind.TypeQuery);
             parseExpected(SyntaxKind.TypeOfKeyword);
             node.exprName = parseEntityName(/*allowReservedWords*/ true);
             return finishNode(node);
         }
 
         function parseTypeParameter(): TypeParameterDeclaration {
-            let node = <TypeParameterDeclaration>createNode(SyntaxKind.TypeParameter);
+            const node = <TypeParameterDeclaration>createNode(SyntaxKind.TypeParameter);
             node.name = parseIdentifier();
             if (parseOptional(SyntaxKind.ExtendsKeyword)) {
                 // It's not uncommon for people to write improper constraints to a generic.  If the
@@ -2004,7 +2004,7 @@ namespace ts {
         }
 
         function parseParameter(): ParameterDeclaration {
-            let node = <ParameterDeclaration>createNode(SyntaxKind.Parameter);
+            const node = <ParameterDeclaration>createNode(SyntaxKind.Parameter);
             node.decorators = parseDecorators();
             setModifiers(node, parseModifiers());
             node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
@@ -2056,7 +2056,7 @@ namespace ts {
                 requireCompleteParameterList: boolean,
                 signature: SignatureDeclaration): void {
 
-            let returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken;
+            const returnTokenRequired = returnToken === SyntaxKind.EqualsGreaterThanToken;
             signature.typeParameters = parseTypeParameters();
             signature.parameters = parseParameterList(yieldContext, awaitContext, requireCompleteParameterList);
 
@@ -2084,13 +2084,13 @@ namespace ts {
             // SingleNameBinding [Yield,Await]:
             //      BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt
             if (parseExpected(SyntaxKind.OpenParenToken)) {
-                let savedYieldContext = inYieldContext();
-                let savedAwaitContext = inAwaitContext();
+                const savedYieldContext = inYieldContext();
+                const savedAwaitContext = inAwaitContext();
 
                 setYieldContext(yieldContext);
                 setAwaitContext(awaitContext);
 
-                let result = parseDelimitedList(ParsingContext.Parameters, parseParameter);
+                const result = parseDelimitedList(ParsingContext.Parameters, parseParameter);
 
                 setYieldContext(savedYieldContext);
                 setAwaitContext(savedAwaitContext);
@@ -2122,7 +2122,7 @@ namespace ts {
         }
 
         function parseSignatureMember(kind: SyntaxKind): SignatureDeclaration {
-            let node = <SignatureDeclaration>createNode(kind);
+            const node = <SignatureDeclaration>createNode(kind);
             if (kind === SyntaxKind.ConstructSignature) {
                 parseExpected(SyntaxKind.NewKeyword);
             }
@@ -2195,7 +2195,7 @@ namespace ts {
         }
 
         function parseIndexSignatureDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): IndexSignatureDeclaration {
-            let node = <IndexSignatureDeclaration>createNode(SyntaxKind.IndexSignature, fullStart);
+            const node = <IndexSignatureDeclaration>createNode(SyntaxKind.IndexSignature, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.parameters = parseBracketedList(ParsingContext.Parameters, parseParameter, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken);
@@ -2205,12 +2205,12 @@ namespace ts {
         }
 
         function parsePropertyOrMethodSignature(): Declaration {
-            let fullStart = scanner.getStartPos();
-            let name = parsePropertyName();
-            let questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
+            const fullStart = scanner.getStartPos();
+            const name = parsePropertyName();
+            const questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
 
             if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
-                let method = <MethodDeclaration>createNode(SyntaxKind.MethodSignature, fullStart);
+                const method = <MethodDeclaration>createNode(SyntaxKind.MethodSignature, fullStart);
                 method.name = name;
                 method.questionToken = questionToken;
 
@@ -2221,7 +2221,7 @@ namespace ts {
                 return finishNode(method);
             }
             else {
-                let property = <PropertyDeclaration>createNode(SyntaxKind.PropertySignature, fullStart);
+                const property = <PropertyDeclaration>createNode(SyntaxKind.PropertySignature, fullStart);
                 property.name = name;
                 property.questionToken = questionToken;
                 property.type = parseTypeAnnotation();
@@ -2238,7 +2238,7 @@ namespace ts {
                     return true;
                 default:
                     if (isModifier(token)) {
-                        let result = lookAhead(isStartOfIndexSignatureDeclaration);
+                        const result = lookAhead(isStartOfIndexSignatureDeclaration);
                         if (result) {
                             return result;
                         }
@@ -2291,7 +2291,7 @@ namespace ts {
                     // if it has the same text regardless of whether it is inside a class or an
                     // object type.
                     if (isModifier(token)) {
-                        let result = tryParse(parseIndexSignatureWithModifiers);
+                        const result = tryParse(parseIndexSignatureWithModifiers);
                         if (result) {
                             return result;
                         }
@@ -2304,9 +2304,9 @@ namespace ts {
         }
 
         function parseIndexSignatureWithModifiers() {
-            let fullStart = scanner.getStartPos();
-            let decorators = parseDecorators();
-            let modifiers = parseModifiers();
+            const fullStart = scanner.getStartPos();
+            const decorators = parseDecorators();
+            const modifiers = parseModifiers();
             return isIndexSignature()
                 ? parseIndexSignatureDeclaration(fullStart, decorators, modifiers)
                 : undefined;
@@ -2318,7 +2318,7 @@ namespace ts {
         }
 
         function parseTypeLiteral(): TypeLiteralNode {
-            let node = <TypeLiteralNode>createNode(SyntaxKind.TypeLiteral);
+            const node = <TypeLiteralNode>createNode(SyntaxKind.TypeLiteral);
             node.members = parseObjectTypeMembers();
             return finishNode(node);
         }
@@ -2337,13 +2337,13 @@ namespace ts {
         }
 
         function parseTupleType(): TupleTypeNode {
-            let node = <TupleTypeNode>createNode(SyntaxKind.TupleType);
+            const node = <TupleTypeNode>createNode(SyntaxKind.TupleType);
             node.elementTypes = parseBracketedList(ParsingContext.TupleElementTypes, parseType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken);
             return finishNode(node);
         }
 
         function parseParenthesizedType(): ParenthesizedTypeNode {
-            let node = <ParenthesizedTypeNode>createNode(SyntaxKind.ParenthesizedType);
+            const node = <ParenthesizedTypeNode>createNode(SyntaxKind.ParenthesizedType);
             parseExpected(SyntaxKind.OpenParenToken);
             node.type = parseType();
             parseExpected(SyntaxKind.CloseParenToken);
@@ -2351,7 +2351,7 @@ namespace ts {
         }
 
         function parseFunctionOrConstructorType(kind: SyntaxKind): FunctionOrConstructorTypeNode {
-            let node = <FunctionOrConstructorTypeNode>createNode(kind);
+            const node = <FunctionOrConstructorTypeNode>createNode(kind);
             if (kind === SyntaxKind.ConstructorType) {
                 parseExpected(SyntaxKind.NewKeyword);
             }
@@ -2360,7 +2360,7 @@ namespace ts {
         }
 
         function parseKeywordAndNoDot(): TypeNode {
-            let node = parseTokenNode<TypeNode>();
+            const node = parseTokenNode<TypeNode>();
             return token === SyntaxKind.DotToken ? undefined : node;
         }
 
@@ -2372,7 +2372,7 @@ namespace ts {
                 case SyntaxKind.BooleanKeyword:
                 case SyntaxKind.SymbolKeyword:
                     // If these are followed by a dot, then parse these out as a dotted type reference instead.
-                    let node = tryParse(parseKeywordAndNoDot);
+                    const node = tryParse(parseKeywordAndNoDot);
                     return node || parseTypeReferenceOrTypePredicate();
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.ThisKeyword:
@@ -2423,7 +2423,7 @@ namespace ts {
             let type = parseNonArrayType();
             while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
                 parseExpected(SyntaxKind.CloseBracketToken);
-                let node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
+                const node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
                 node.elementType = type;
                 type = finishNode(node);
             }
@@ -2433,13 +2433,13 @@ namespace ts {
         function parseUnionOrIntersectionType(kind: SyntaxKind, parseConstituentType: () => TypeNode, operator: SyntaxKind): TypeNode {
             let type = parseConstituentType();
             if (token === operator) {
-                let types = <NodeArray<TypeNode>>[type];
+                const types = <NodeArray<TypeNode>>[type];
                 types.pos = type.pos;
                 while (parseOptional(operator)) {
                     types.push(parseConstituentType());
                 }
                 types.end = getNodeEnd();
-                let node = <UnionOrIntersectionTypeNode>createNode(kind, type.pos);
+                const node = <UnionOrIntersectionTypeNode>createNode(kind, type.pos);
                 node.types = types;
                 type = finishNode(node);
             }
@@ -2593,7 +2593,7 @@ namespace ts {
             //      Expression[in] , AssignmentExpression[in]
 
             // clear the decorator context when parsing Expression, as it should be unambiguous when parsing a decorator
-            let saveDecoratorContext = inDecoratorContext();
+            const saveDecoratorContext = inDecoratorContext();
             if (saveDecoratorContext) {
                 setDecoratorContext(false);
             }
@@ -2654,7 +2654,7 @@ namespace ts {
             // parameter list. If we do, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a  LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            let arrowExpression = tryParseParenthesizedArrowFunctionExpression();
+            const arrowExpression = tryParseParenthesizedArrowFunctionExpression();
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -2668,7 +2668,7 @@ namespace ts {
             // Otherwise, we try to parse out the conditional expression bit.  We want to allow any
             // binary expression here, so we pass in the 'lowest' precedence here so that it matches
             // and consumes anything.
-            let expr = parseBinaryExpressionOrHigher(/*precedence*/ 0);
+            const expr = parseBinaryExpressionOrHigher(/*precedence*/ 0);
 
             // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
@@ -2725,7 +2725,7 @@ namespace ts {
         }
 
         function parseYieldExpression(): YieldExpression {
-            let node = <YieldExpression>createNode(SyntaxKind.YieldExpression);
+            const node = <YieldExpression>createNode(SyntaxKind.YieldExpression);
 
             // YieldExpression[In] :
             //      yield
@@ -2749,9 +2749,9 @@ namespace ts {
         function parseSimpleArrowFunctionExpression(identifier: Identifier): Expression {
             Debug.assert(token === SyntaxKind.EqualsGreaterThanToken, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
 
-            let node = <ArrowFunction>createNode(SyntaxKind.ArrowFunction, identifier.pos);
+            const node = <ArrowFunction>createNode(SyntaxKind.ArrowFunction, identifier.pos);
 
-            let parameter = <ParameterDeclaration>createNode(SyntaxKind.Parameter, identifier.pos);
+            const parameter = <ParameterDeclaration>createNode(SyntaxKind.Parameter, identifier.pos);
             parameter.name = identifier;
             finishNode(parameter);
 
@@ -2766,7 +2766,7 @@ namespace ts {
         }
 
         function tryParseParenthesizedArrowFunctionExpression(): Expression {
-            let triState = isParenthesizedArrowFunctionExpression();
+            const triState = isParenthesizedArrowFunctionExpression();
             if (triState === Tristate.False) {
                 // It's definitely not a parenthesized arrow function expression.
                 return undefined;
@@ -2776,7 +2776,7 @@ namespace ts {
             // following => or { token. Otherwise, we *might* have an arrow function.  Try to parse
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
-            let arrowFunction = triState === Tristate.True
+            const arrowFunction = triState === Tristate.True
                 ? parseParenthesizedArrowFunctionExpressionHead(/*allowAmbiguity*/ true)
                 : tryParse(parsePossibleParenthesizedArrowFunctionExpressionHead);
 
@@ -2785,11 +2785,11 @@ namespace ts {
                 return undefined;
             }
 
-            let isAsync = !!(arrowFunction.flags & NodeFlags.Async);
+            const isAsync = !!(arrowFunction.flags & NodeFlags.Async);
 
             // If we have an arrow, then try to parse the body. Even if not, try to parse if we
             // have an opening brace, just in case we're in an error state.
-            let lastToken = token;
+            const lastToken = token;
             arrowFunction.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition*/false, Diagnostics._0_expected, "=>");
             arrowFunction.body = (lastToken === SyntaxKind.EqualsGreaterThanToken || lastToken === SyntaxKind.OpenBraceToken)
                 ? parseArrowFunctionExpressionBody(isAsync)
@@ -2828,8 +2828,8 @@ namespace ts {
                 }
             }
 
-            let first = token;
-            let second = nextToken();
+            const first = token;
+            const second = nextToken();
 
             if (first === SyntaxKind.OpenParenToken) {
                 if (second === SyntaxKind.CloseParenToken) {
@@ -2837,7 +2837,7 @@ namespace ts {
                     // This is an arrow function with no parameters.
                     // The last one is not actually an arrow function,
                     // but this is probably what the user intended.
-                    let third = nextToken();
+                    const third = nextToken();
                     switch (third) {
                         case SyntaxKind.EqualsGreaterThanToken:
                         case SyntaxKind.ColonToken:
@@ -2880,7 +2880,7 @@ namespace ts {
                 }
 
                 // This *could* be a parenthesized arrow function.
-                // Return Unknown to let the caller know.
+                // Return Unknown to const the caller know.
                 return Tristate.Unknown;
             }
             else {
@@ -2894,10 +2894,10 @@ namespace ts {
 
                 // JSX overrides
                 if (sourceFile.languageVariant === LanguageVariant.JSX) {
-                    let isArrowFunctionInJsx = lookAhead(() => {
-                        let third = nextToken();
+                    const isArrowFunctionInJsx = lookAhead(() => {
+                        const third = nextToken();
                         if (third === SyntaxKind.ExtendsKeyword) {
-                            let fourth = nextToken();
+                            const fourth = nextToken();
                             switch (fourth) {
                                 case SyntaxKind.EqualsToken:
                                 case SyntaxKind.GreaterThanToken:
@@ -2929,9 +2929,9 @@ namespace ts {
         }
 
         function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction {
-            let node = <ArrowFunction>createNode(SyntaxKind.ArrowFunction);
+            const node = <ArrowFunction>createNode(SyntaxKind.ArrowFunction);
             setModifiers(node, parseModifiersForArrowFunction());
-            let isAsync = !!(node.flags & NodeFlags.Async);
+            const isAsync = !!(node.flags & NodeFlags.Async);
 
             // Arrow functions are never generators.
             //
@@ -2979,7 +2979,7 @@ namespace ts {
                 // user meant to supply a block. For example, if the user wrote:
                 //
                 //  a =>
-                //      let v = 0;
+                //      const v = 0;
                 //  }
                 //
                 // they may be missing an open brace.  Check to see if that's the case so we can
@@ -2997,14 +2997,14 @@ namespace ts {
 
         function parseConditionalExpressionRest(leftOperand: Expression): Expression {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
-            let questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
+            const questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             if (!questionToken) {
                 return leftOperand;
             }
 
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
-            let node = <ConditionalExpression>createNode(SyntaxKind.ConditionalExpression, leftOperand.pos);
+            const node = <ConditionalExpression>createNode(SyntaxKind.ConditionalExpression, leftOperand.pos);
             node.condition = leftOperand;
             node.questionToken = questionToken;
             node.whenTrue = doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher);
@@ -3015,7 +3015,7 @@ namespace ts {
         }
 
         function parseBinaryExpressionOrHigher(precedence: number): Expression {
-            let leftOperand = parseUnaryExpressionOrHigher();
+            const leftOperand = parseUnaryExpressionOrHigher();
             return parseBinaryExpressionRest(precedence, leftOperand);
         }
 
@@ -3029,7 +3029,7 @@ namespace ts {
                 // reScanGreaterToken so that we merge token sequences like > and = into >=
 
                 reScanGreaterToken();
-                let newPrecedence = getBinaryOperatorPrecedence();
+                const newPrecedence = getBinaryOperatorPrecedence();
 
                 // Check the precedence to see if we should "take" this operator
                 // - For left associative operator (all operator but **), consume the operator,
@@ -3140,7 +3140,7 @@ namespace ts {
         }
 
         function makeBinaryExpression(left: Expression, operatorToken: Node, right: Expression): BinaryExpression {
-            let node = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, left.pos);
+            const node = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, left.pos);
             node.left = left;
             node.operatorToken = operatorToken;
             node.right = right;
@@ -3148,14 +3148,14 @@ namespace ts {
         }
 
         function makeAsExpression(left: Expression, right: TypeNode): AsExpression {
-            let node = <AsExpression>createNode(SyntaxKind.AsExpression, left.pos);
+            const node = <AsExpression>createNode(SyntaxKind.AsExpression, left.pos);
             node.expression = left;
             node.type = right;
             return finishNode(node);
         }
 
         function parsePrefixUnaryExpression() {
-            let node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
+            const node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
             node.operator = token;
             nextToken();
             node.operand = parseSimpleUnaryExpression();
@@ -3164,21 +3164,21 @@ namespace ts {
         }
 
         function parseDeleteExpression() {
-            let node = <DeleteExpression>createNode(SyntaxKind.DeleteExpression);
+            const node = <DeleteExpression>createNode(SyntaxKind.DeleteExpression);
             nextToken();
             node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
         function parseTypeOfExpression() {
-            let node = <TypeOfExpression>createNode(SyntaxKind.TypeOfExpression);
+            const node = <TypeOfExpression>createNode(SyntaxKind.TypeOfExpression);
             nextToken();
             node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
         }
 
         function parseVoidExpression() {
-            let node = <VoidExpression>createNode(SyntaxKind.VoidExpression);
+            const node = <VoidExpression>createNode(SyntaxKind.VoidExpression);
             nextToken();
             node.expression = parseSimpleUnaryExpression();
             return finishNode(node);
@@ -3217,17 +3217,16 @@ namespace ts {
             }
 
             if (isIncrementExpression()) {
-                let incrementExpression = parseIncrementExpression();
+                const incrementExpression = parseIncrementExpression();
                 return token === SyntaxKind.AsteriskAsteriskToken ?
                     <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
 
-            let unaryOperator = token;
-            let simpleUnaryExpression = parseSimpleUnaryExpression();
+            const unaryOperator = token;
+            const simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token === SyntaxKind.AsteriskAsteriskToken) {
-                let diagnostic: Diagnostic;
-                let start = skipTrivia(sourceText, simpleUnaryExpression.pos);
+                const start = skipTrivia(sourceText, simpleUnaryExpression.pos);
                 if (simpleUnaryExpression.kind === SyntaxKind.TypeAssertionExpression) {
                     parseErrorAtPosition(start, simpleUnaryExpression.end - start, Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
                 }
@@ -3321,7 +3320,7 @@ namespace ts {
          */
         function parseIncrementExpression(): IncrementExpression {
             if (token === SyntaxKind.PlusPlusToken || token === SyntaxKind.MinusMinusToken) {
-                let node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
+                const node = <PrefixUnaryExpression>createNode(SyntaxKind.PrefixUnaryExpression);
                 node.operator = token;
                 nextToken();
                 node.operand = parseLeftHandSideExpressionOrHigher();
@@ -3332,11 +3331,11 @@ namespace ts {
                 return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ true);
             }
 
-            let expression = parseLeftHandSideExpressionOrHigher();
+            const expression = parseLeftHandSideExpressionOrHigher();
 
             Debug.assert(isLeftHandSideExpression(expression));
             if ((token === SyntaxKind.PlusPlusToken || token === SyntaxKind.MinusMinusToken) && !scanner.hasPrecedingLineBreak()) {
-                let node = <PostfixUnaryExpression>createNode(SyntaxKind.PostfixUnaryExpression, expression.pos);
+                const node = <PostfixUnaryExpression>createNode(SyntaxKind.PostfixUnaryExpression, expression.pos);
                 node.operand = expression;
                 node.operator = token;
                 nextToken();
@@ -3377,7 +3376,7 @@ namespace ts {
             // the last two CallExpression productions.  Or we have a MemberExpression which either
             // completes the LeftHandSideExpression, or starts the beginning of the first four
             // CallExpression productions.
-            let expression = token === SyntaxKind.SuperKeyword
+            const expression = token === SyntaxKind.SuperKeyword
                 ? parseSuperExpression()
                 : parseMemberExpressionOrHigher();
 
@@ -3434,19 +3433,19 @@ namespace ts {
             //
             // Because CallExpression and MemberExpression are left recursive, we need to bottom out
             // of the recursion immediately.  So we parse out a primary expression to start with.
-            let expression = parsePrimaryExpression();
+            const expression = parsePrimaryExpression();
             return parseMemberExpressionRest(expression);
         }
 
         function parseSuperExpression(): MemberExpression {
-            let expression = parseTokenNode<PrimaryExpression>();
+            const expression = parseTokenNode<PrimaryExpression>();
             if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.DotToken || token === SyntaxKind.OpenBracketToken) {
                 return expression;
             }
 
             // If we have seen "super" it must be followed by '(' or '.'.
             // If it wasn't then just try to parse out a '.' and report an error.
-            let node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
+            const node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
             node.expression = expression;
             node.dotToken = parseExpectedToken(SyntaxKind.DotToken, /*reportAtCurrentPosition*/ false, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
             node.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
@@ -3454,10 +3453,10 @@ namespace ts {
         }
 
         function parseJsxElementOrSelfClosingElement(inExpressionContext: boolean): JsxElement | JsxSelfClosingElement {
-            let opening = parseJsxOpeningOrSelfClosingElement(inExpressionContext);
+            const opening = parseJsxOpeningOrSelfClosingElement(inExpressionContext);
             let result: JsxElement | JsxSelfClosingElement;
             if (opening.kind === SyntaxKind.JsxOpeningElement) {
-                let node = <JsxElement>createNode(SyntaxKind.JsxElement, opening.pos);
+                const node = <JsxElement>createNode(SyntaxKind.JsxElement, opening.pos);
                 node.openingElement = opening;
 
                 node.children = parseJsxChildren(node.openingElement.tagName);
@@ -3478,10 +3477,10 @@ namespace ts {
             // Since JSX elements are invalid < operands anyway, this lookahead parse will only occur in error scenarios
             // of one sort or another.
             if (inExpressionContext && token === SyntaxKind.LessThanToken) {
-                let invalidElement = tryParse(() => parseJsxElementOrSelfClosingElement(/*inExpressionContext*/true));
+                const invalidElement = tryParse(() => parseJsxElementOrSelfClosingElement(/*inExpressionContext*/true));
                 if (invalidElement) {
                     parseErrorAtCurrentToken(Diagnostics.JSX_expressions_must_have_one_parent_element);
-                    let badNode = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, result.pos);
+                    const badNode = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, result.pos);
                     badNode.end = invalidElement.end;
                     badNode.left = result;
                     badNode.right = invalidElement;
@@ -3495,7 +3494,7 @@ namespace ts {
         }
 
         function parseJsxText(): JsxText {
-            let node = <JsxText>createNode(SyntaxKind.JsxText, scanner.getStartPos());
+            const node = <JsxText>createNode(SyntaxKind.JsxText, scanner.getStartPos());
             token = scanner.scanJsxToken();
             return finishNode(node);
         }
@@ -3513,9 +3512,9 @@ namespace ts {
         }
 
         function parseJsxChildren(openingTagName: EntityName): NodeArray<JsxChild> {
-            let result = <NodeArray<JsxChild>>[];
+            const result = <NodeArray<JsxChild>>[];
             result.pos = scanner.getStartPos();
-            let saveParsingContext = parsingContext;
+            const saveParsingContext = parsingContext;
             parsingContext |= 1 << ParsingContext.JsxChildren;
 
             while (true) {
@@ -3538,13 +3537,13 @@ namespace ts {
         }
 
         function parseJsxOpeningOrSelfClosingElement(inExpressionContext: boolean): JsxOpeningElement | JsxSelfClosingElement {
-            let fullStart = scanner.getStartPos();
+            const fullStart = scanner.getStartPos();
 
             parseExpected(SyntaxKind.LessThanToken);
 
-            let tagName = parseJsxElementName();
+            const tagName = parseJsxElementName();
 
-            let attributes = parseList(ParsingContext.JsxAttributes, parseJsxAttribute);
+            const attributes = parseList(ParsingContext.JsxAttributes, parseJsxAttribute);
             let node: JsxOpeningLikeElement;
 
             if (token === SyntaxKind.GreaterThanToken) {
@@ -3577,7 +3576,7 @@ namespace ts {
             let elementName: EntityName = parseIdentifierName();
             while (parseOptional(SyntaxKind.DotToken)) {
                 scanJsxIdentifier();
-                let node = <QualifiedName>createNode(SyntaxKind.QualifiedName, elementName.pos);
+                const node = <QualifiedName>createNode(SyntaxKind.QualifiedName, elementName.pos);
                 node.left = elementName;
                 node.right = parseIdentifierName();
                 elementName = finishNode(node);
@@ -3586,7 +3585,7 @@ namespace ts {
         }
 
         function parseJsxExpression(inExpressionContext: boolean): JsxExpression {
-            let node = <JsxExpression>createNode(SyntaxKind.JsxExpression);
+            const node = <JsxExpression>createNode(SyntaxKind.JsxExpression);
 
             parseExpected(SyntaxKind.OpenBraceToken);
             if (token !== SyntaxKind.CloseBraceToken) {
@@ -3609,7 +3608,7 @@ namespace ts {
             }
 
             scanJsxIdentifier();
-            let node = <JsxAttribute>createNode(SyntaxKind.JsxAttribute);
+            const node = <JsxAttribute>createNode(SyntaxKind.JsxAttribute);
             node.name = parseIdentifierName();
             if (parseOptional(SyntaxKind.EqualsToken)) {
                 switch (token) {
@@ -3625,7 +3624,7 @@ namespace ts {
         }
 
         function parseJsxSpreadAttribute(): JsxSpreadAttribute {
-            let node = <JsxSpreadAttribute>createNode(SyntaxKind.JsxSpreadAttribute);
+            const node = <JsxSpreadAttribute>createNode(SyntaxKind.JsxSpreadAttribute);
             parseExpected(SyntaxKind.OpenBraceToken);
             parseExpected(SyntaxKind.DotDotDotToken);
             node.expression = parseExpression();
@@ -3634,7 +3633,7 @@ namespace ts {
         }
 
         function parseJsxClosingElement(inExpressionContext: boolean): JsxClosingElement {
-            let node = <JsxClosingElement>createNode(SyntaxKind.JsxClosingElement);
+            const node = <JsxClosingElement>createNode(SyntaxKind.JsxClosingElement);
             parseExpected(SyntaxKind.LessThanSlashToken);
             node.tagName = parseJsxElementName();
             if (inExpressionContext) {
@@ -3648,7 +3647,7 @@ namespace ts {
         }
 
         function parseTypeAssertion(): TypeAssertion {
-            let node = <TypeAssertion>createNode(SyntaxKind.TypeAssertionExpression);
+            const node = <TypeAssertion>createNode(SyntaxKind.TypeAssertionExpression);
             parseExpected(SyntaxKind.LessThanToken);
             node.type = parseType();
             parseExpected(SyntaxKind.GreaterThanToken);
@@ -3658,9 +3657,9 @@ namespace ts {
 
         function parseMemberExpressionRest(expression: LeftHandSideExpression): MemberExpression {
             while (true) {
-                let dotToken = parseOptionalToken(SyntaxKind.DotToken);
+                const dotToken = parseOptionalToken(SyntaxKind.DotToken);
                 if (dotToken) {
-                    let propertyAccess = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
+                    const propertyAccess = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
                     propertyAccess.expression = expression;
                     propertyAccess.dotToken = dotToken;
                     propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
@@ -3670,7 +3669,7 @@ namespace ts {
 
                 // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName
                 if (!inDecoratorContext() && parseOptional(SyntaxKind.OpenBracketToken)) {
-                    let indexedAccess = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression, expression.pos);
+                    const indexedAccess = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression, expression.pos);
                     indexedAccess.expression = expression;
 
                     // It's not uncommon for a user to write: "new Type[]".
@@ -3678,7 +3677,7 @@ namespace ts {
                     if (token !== SyntaxKind.CloseBracketToken) {
                         indexedAccess.argumentExpression = allowInAnd(parseExpression);
                         if (indexedAccess.argumentExpression.kind === SyntaxKind.StringLiteral || indexedAccess.argumentExpression.kind === SyntaxKind.NumericLiteral) {
-                            let literal = <LiteralExpression>indexedAccess.argumentExpression;
+                            const literal = <LiteralExpression>indexedAccess.argumentExpression;
                             literal.text = internIdentifier(literal.text);
                         }
                     }
@@ -3689,7 +3688,7 @@ namespace ts {
                 }
 
                 if (token === SyntaxKind.NoSubstitutionTemplateLiteral || token === SyntaxKind.TemplateHead) {
-                    let tagExpression = <TaggedTemplateExpression>createNode(SyntaxKind.TaggedTemplateExpression, expression.pos);
+                    const tagExpression = <TaggedTemplateExpression>createNode(SyntaxKind.TaggedTemplateExpression, expression.pos);
                     tagExpression.tag = expression;
                     tagExpression.template = token === SyntaxKind.NoSubstitutionTemplateLiteral
                         ? parseLiteralNode()
@@ -3710,12 +3709,12 @@ namespace ts {
                     // keep checking for postfix expressions.  Otherwise, it's just a '<' that's
                     // part of an arithmetic expression.  Break out so we consume it higher in the
                     // stack.
-                    let typeArguments = tryParse(parseTypeArgumentsInExpression);
+                    const typeArguments = tryParse(parseTypeArgumentsInExpression);
                     if (!typeArguments) {
                         return expression;
                     }
 
-                    let callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
+                    const callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
                     callExpr.expression = expression;
                     callExpr.typeArguments = typeArguments;
                     callExpr.arguments = parseArgumentList();
@@ -3723,7 +3722,7 @@ namespace ts {
                     continue;
                 }
                 else if (token === SyntaxKind.OpenParenToken) {
-                    let callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
+                    const callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
                     callExpr.expression = expression;
                     callExpr.arguments = parseArgumentList();
                     expression = finishNode(callExpr);
@@ -3736,7 +3735,7 @@ namespace ts {
 
         function parseArgumentList() {
             parseExpected(SyntaxKind.OpenParenToken);
-            let result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
+            const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
             parseExpected(SyntaxKind.CloseParenToken);
             return result;
         }
@@ -3746,7 +3745,7 @@ namespace ts {
                 return undefined;
             }
 
-            let typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
+            const typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
             if (!parseExpected(SyntaxKind.GreaterThanToken)) {
                 // If it doesn't have the closing >  then it's definitely not an type argument list.
                 return undefined;
@@ -3846,7 +3845,7 @@ namespace ts {
         }
 
         function parseParenthesizedExpression(): ParenthesizedExpression {
-            let node = <ParenthesizedExpression>createNode(SyntaxKind.ParenthesizedExpression);
+            const node = <ParenthesizedExpression>createNode(SyntaxKind.ParenthesizedExpression);
             parseExpected(SyntaxKind.OpenParenToken);
             node.expression = allowInAnd(parseExpression);
             parseExpected(SyntaxKind.CloseParenToken);
@@ -3854,7 +3853,7 @@ namespace ts {
         }
 
         function parseSpreadElement(): Expression {
-            let node = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression);
+            const node = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression);
             parseExpected(SyntaxKind.DotDotDotToken);
             node.expression = parseAssignmentExpressionOrHigher();
             return finishNode(node);
@@ -3871,7 +3870,7 @@ namespace ts {
         }
 
         function parseArrayLiteralExpression(): ArrayLiteralExpression {
-            let node = <ArrayLiteralExpression>createNode(SyntaxKind.ArrayLiteralExpression);
+            const node = <ArrayLiteralExpression>createNode(SyntaxKind.ArrayLiteralExpression);
             parseExpected(SyntaxKind.OpenBracketToken);
             if (scanner.hasPrecedingLineBreak()) node.flags |= NodeFlags.MultiLine;
             node.elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement);
@@ -3891,22 +3890,22 @@ namespace ts {
         }
 
         function parseObjectLiteralElement(): ObjectLiteralElement {
-            let fullStart = scanner.getStartPos();
-            let decorators = parseDecorators();
-            let modifiers = parseModifiers();
+            const fullStart = scanner.getStartPos();
+            const decorators = parseDecorators();
+            const modifiers = parseModifiers();
 
-            let accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
+            const accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
             if (accessor) {
                 return accessor;
             }
 
-            let asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
-            let tokenIsIdentifier = isIdentifier();
-            let nameToken = token;
-            let propertyName = parsePropertyName();
+            const asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
+            const tokenIsIdentifier = isIdentifier();
+            const nameToken = token;
+            const propertyName = parsePropertyName();
 
             // Disallowing of optional property assignments happens in the grammar checker.
-            let questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
+            const questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             if (asteriskToken || token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
                 return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken);
             }
@@ -3920,7 +3919,7 @@ namespace ts {
                 tokenIsIdentifier && (token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken || token === SyntaxKind.EqualsToken);
 
             if (isShorthandPropertyAssignment) {
-                let shorthandDeclaration = <ShorthandPropertyAssignment>createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart);
+                const shorthandDeclaration = <ShorthandPropertyAssignment>createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart);
                 shorthandDeclaration.name = <Identifier>propertyName;
                 shorthandDeclaration.questionToken = questionToken;
                 const equalsToken = parseOptionalToken(SyntaxKind.EqualsToken);
@@ -3931,7 +3930,7 @@ namespace ts {
                 return finishNode(shorthandDeclaration);
             }
             else {
-                let propertyAssignment = <PropertyAssignment>createNode(SyntaxKind.PropertyAssignment, fullStart);
+                const propertyAssignment = <PropertyAssignment>createNode(SyntaxKind.PropertyAssignment, fullStart);
                 propertyAssignment.name = propertyName;
                 propertyAssignment.questionToken = questionToken;
                 parseExpected(SyntaxKind.ColonToken);
@@ -3941,7 +3940,7 @@ namespace ts {
         }
 
         function parseObjectLiteralExpression(): ObjectLiteralExpression {
-            let node = <ObjectLiteralExpression>createNode(SyntaxKind.ObjectLiteralExpression);
+            const node = <ObjectLiteralExpression>createNode(SyntaxKind.ObjectLiteralExpression);
             parseExpected(SyntaxKind.OpenBraceToken);
             if (scanner.hasPrecedingLineBreak()) {
                 node.flags |= NodeFlags.MultiLine;
@@ -3958,18 +3957,18 @@ namespace ts {
             //
             // FunctionExpression:
             //      function BindingIdentifier[opt](FormalParameters){ FunctionBody }
-            let saveDecoratorContext = inDecoratorContext();
+            const saveDecoratorContext = inDecoratorContext();
             if (saveDecoratorContext) {
                 setDecoratorContext(false);
             }
 
-            let node = <FunctionExpression>createNode(SyntaxKind.FunctionExpression);
+            const node = <FunctionExpression>createNode(SyntaxKind.FunctionExpression);
             setModifiers(node, parseModifiers());
             parseExpected(SyntaxKind.FunctionKeyword);
             node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
 
-            let isGenerator = !!node.asteriskToken;
-            let isAsync = !!(node.flags & NodeFlags.Async);
+            const isGenerator = !!node.asteriskToken;
+            const isAsync = !!(node.flags & NodeFlags.Async);
             node.name =
                 isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :
                 isGenerator ? doInYieldContext(parseOptionalIdentifier) :
@@ -3991,7 +3990,7 @@ namespace ts {
         }
 
         function parseNewExpression(): NewExpression {
-            let node = <NewExpression>createNode(SyntaxKind.NewExpression);
+            const node = <NewExpression>createNode(SyntaxKind.NewExpression);
             parseExpected(SyntaxKind.NewKeyword);
             node.expression = parseMemberExpressionOrHigher();
             node.typeArguments = tryParse(parseTypeArgumentsInExpression);
@@ -4004,7 +4003,7 @@ namespace ts {
 
         // STATEMENTS
         function parseBlock(ignoreMissingOpenBrace: boolean, diagnosticMessage?: DiagnosticMessage): Block {
-            let node = <Block>createNode(SyntaxKind.Block);
+            const node = <Block>createNode(SyntaxKind.Block);
             if (parseExpected(SyntaxKind.OpenBraceToken, diagnosticMessage) || ignoreMissingOpenBrace) {
                 node.statements = parseList(ParsingContext.BlockStatements, parseStatement);
                 parseExpected(SyntaxKind.CloseBraceToken);
@@ -4016,20 +4015,20 @@ namespace ts {
         }
 
         function parseFunctionBlock(allowYield: boolean, allowAwait: boolean, ignoreMissingOpenBrace: boolean, diagnosticMessage?: DiagnosticMessage): Block {
-            let savedYieldContext = inYieldContext();
+            const savedYieldContext = inYieldContext();
             setYieldContext(allowYield);
 
-            let savedAwaitContext = inAwaitContext();
+            const savedAwaitContext = inAwaitContext();
             setAwaitContext(allowAwait);
 
             // We may be in a [Decorator] context when parsing a function expression or
             // arrow function. The body of the function is not in [Decorator] context.
-            let saveDecoratorContext = inDecoratorContext();
+            const saveDecoratorContext = inDecoratorContext();
             if (saveDecoratorContext) {
                 setDecoratorContext(false);
             }
 
-            let block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage);
+            const block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage);
 
             if (saveDecoratorContext) {
                 setDecoratorContext(true);
@@ -4042,13 +4041,13 @@ namespace ts {
         }
 
         function parseEmptyStatement(): Statement {
-            let node = <Statement>createNode(SyntaxKind.EmptyStatement);
+            const node = <Statement>createNode(SyntaxKind.EmptyStatement);
             parseExpected(SyntaxKind.SemicolonToken);
             return finishNode(node);
         }
 
         function parseIfStatement(): IfStatement {
-            let node = <IfStatement>createNode(SyntaxKind.IfStatement);
+            const node = <IfStatement>createNode(SyntaxKind.IfStatement);
             parseExpected(SyntaxKind.IfKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
             node.expression = allowInAnd(parseExpression);
@@ -4059,7 +4058,7 @@ namespace ts {
         }
 
         function parseDoStatement(): DoStatement {
-            let node = <DoStatement>createNode(SyntaxKind.DoStatement);
+            const node = <DoStatement>createNode(SyntaxKind.DoStatement);
             parseExpected(SyntaxKind.DoKeyword);
             node.statement = parseStatement();
             parseExpected(SyntaxKind.WhileKeyword);
@@ -4076,7 +4075,7 @@ namespace ts {
         }
 
         function parseWhileStatement(): WhileStatement {
-            let node = <WhileStatement>createNode(SyntaxKind.WhileStatement);
+            const node = <WhileStatement>createNode(SyntaxKind.WhileStatement);
             parseExpected(SyntaxKind.WhileKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
             node.expression = allowInAnd(parseExpression);
@@ -4086,7 +4085,7 @@ namespace ts {
         }
 
         function parseForOrForInOrForOfStatement(): Statement {
-            let pos = getNodePos();
+            const pos = getNodePos();
             parseExpected(SyntaxKind.ForKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
 
@@ -4101,21 +4100,21 @@ namespace ts {
             }
             let forOrForInOrForOfStatement: IterationStatement;
             if (parseOptional(SyntaxKind.InKeyword)) {
-                let forInStatement = <ForInStatement>createNode(SyntaxKind.ForInStatement, pos);
+                const forInStatement = <ForInStatement>createNode(SyntaxKind.ForInStatement, pos);
                 forInStatement.initializer = initializer;
                 forInStatement.expression = allowInAnd(parseExpression);
                 parseExpected(SyntaxKind.CloseParenToken);
                 forOrForInOrForOfStatement = forInStatement;
             }
             else if (parseOptional(SyntaxKind.OfKeyword)) {
-                let forOfStatement = <ForOfStatement>createNode(SyntaxKind.ForOfStatement, pos);
+                const forOfStatement = <ForOfStatement>createNode(SyntaxKind.ForOfStatement, pos);
                 forOfStatement.initializer = initializer;
                 forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher);
                 parseExpected(SyntaxKind.CloseParenToken);
                 forOrForInOrForOfStatement = forOfStatement;
             }
             else {
-                let forStatement = <ForStatement>createNode(SyntaxKind.ForStatement, pos);
+                const forStatement = <ForStatement>createNode(SyntaxKind.ForStatement, pos);
                 forStatement.initializer = initializer;
                 parseExpected(SyntaxKind.SemicolonToken);
                 if (token !== SyntaxKind.SemicolonToken && token !== SyntaxKind.CloseParenToken) {
@@ -4135,7 +4134,7 @@ namespace ts {
         }
 
         function parseBreakOrContinueStatement(kind: SyntaxKind): BreakOrContinueStatement {
-            let node = <BreakOrContinueStatement>createNode(kind);
+            const node = <BreakOrContinueStatement>createNode(kind);
 
             parseExpected(kind === SyntaxKind.BreakStatement ? SyntaxKind.BreakKeyword : SyntaxKind.ContinueKeyword);
             if (!canParseSemicolon()) {
@@ -4147,7 +4146,7 @@ namespace ts {
         }
 
         function parseReturnStatement(): ReturnStatement {
-            let node = <ReturnStatement>createNode(SyntaxKind.ReturnStatement);
+            const node = <ReturnStatement>createNode(SyntaxKind.ReturnStatement);
 
             parseExpected(SyntaxKind.ReturnKeyword);
             if (!canParseSemicolon()) {
@@ -4159,7 +4158,7 @@ namespace ts {
         }
 
         function parseWithStatement(): WithStatement {
-            let node = <WithStatement>createNode(SyntaxKind.WithStatement);
+            const node = <WithStatement>createNode(SyntaxKind.WithStatement);
             parseExpected(SyntaxKind.WithKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
             node.expression = allowInAnd(parseExpression);
@@ -4169,7 +4168,7 @@ namespace ts {
         }
 
         function parseCaseClause(): CaseClause {
-            let node = <CaseClause>createNode(SyntaxKind.CaseClause);
+            const node = <CaseClause>createNode(SyntaxKind.CaseClause);
             parseExpected(SyntaxKind.CaseKeyword);
             node.expression = allowInAnd(parseExpression);
             parseExpected(SyntaxKind.ColonToken);
@@ -4178,7 +4177,7 @@ namespace ts {
         }
 
         function parseDefaultClause(): DefaultClause {
-            let node = <DefaultClause>createNode(SyntaxKind.DefaultClause);
+            const node = <DefaultClause>createNode(SyntaxKind.DefaultClause);
             parseExpected(SyntaxKind.DefaultKeyword);
             parseExpected(SyntaxKind.ColonToken);
             node.statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
@@ -4190,12 +4189,12 @@ namespace ts {
         }
 
         function parseSwitchStatement(): SwitchStatement {
-            let node = <SwitchStatement>createNode(SyntaxKind.SwitchStatement);
+            const node = <SwitchStatement>createNode(SyntaxKind.SwitchStatement);
             parseExpected(SyntaxKind.SwitchKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
             node.expression = allowInAnd(parseExpression);
             parseExpected(SyntaxKind.CloseParenToken);
-            let caseBlock = <CaseBlock>createNode(SyntaxKind.CaseBlock, scanner.getStartPos());
+            const caseBlock = <CaseBlock>createNode(SyntaxKind.CaseBlock, scanner.getStartPos());
             parseExpected(SyntaxKind.OpenBraceToken);
             caseBlock.clauses = parseList(ParsingContext.SwitchClauses, parseCaseOrDefaultClause);
             parseExpected(SyntaxKind.CloseBraceToken);
@@ -4212,7 +4211,7 @@ namespace ts {
             // directly as that might consume an expression on the following line.
             // We just return 'undefined' in that case.  The actual error will be reported in the
             // grammar walker.
-            let node = <ThrowStatement>createNode(SyntaxKind.ThrowStatement);
+            const node = <ThrowStatement>createNode(SyntaxKind.ThrowStatement);
             parseExpected(SyntaxKind.ThrowKeyword);
             node.expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression);
             parseSemicolon();
@@ -4221,7 +4220,7 @@ namespace ts {
 
         // TODO: Review for error recovery
         function parseTryStatement(): TryStatement {
-            let node = <TryStatement>createNode(SyntaxKind.TryStatement);
+            const node = <TryStatement>createNode(SyntaxKind.TryStatement);
 
             parseExpected(SyntaxKind.TryKeyword);
             node.tryBlock = parseBlock(/*ignoreMissingOpenBrace*/ false);
@@ -4238,7 +4237,7 @@ namespace ts {
         }
 
         function parseCatchClause(): CatchClause {
-            let result = <CatchClause>createNode(SyntaxKind.CatchClause);
+            const result = <CatchClause>createNode(SyntaxKind.CatchClause);
             parseExpected(SyntaxKind.CatchKeyword);
             if (parseExpected(SyntaxKind.OpenParenToken)) {
                 result.variableDeclaration = parseVariableDeclaration();
@@ -4250,7 +4249,7 @@ namespace ts {
         }
 
         function parseDebuggerStatement(): Statement {
-            let node = <Statement>createNode(SyntaxKind.DebuggerStatement);
+            const node = <Statement>createNode(SyntaxKind.DebuggerStatement);
             parseExpected(SyntaxKind.DebuggerKeyword);
             parseSemicolon();
             return finishNode(node);
@@ -4260,17 +4259,17 @@ namespace ts {
             // Avoiding having to do the lookahead for a labeled statement by just trying to parse
             // out an expression, seeing if it is identifier and then seeing if it is followed by
             // a colon.
-            let fullStart = scanner.getStartPos();
-            let expression = allowInAnd(parseExpression);
+            const fullStart = scanner.getStartPos();
+            const expression = allowInAnd(parseExpression);
 
             if (expression.kind === SyntaxKind.Identifier && parseOptional(SyntaxKind.ColonToken)) {
-                let labeledStatement = <LabeledStatement>createNode(SyntaxKind.LabeledStatement, fullStart);
+                const labeledStatement = <LabeledStatement>createNode(SyntaxKind.LabeledStatement, fullStart);
                 labeledStatement.label = <Identifier>expression;
                 labeledStatement.statement = parseStatement();
                 return finishNode(labeledStatement);
             }
             else {
-                let expressionStatement = <ExpressionStatement>createNode(SyntaxKind.ExpressionStatement, fullStart);
+                const expressionStatement = <ExpressionStatement>createNode(SyntaxKind.ExpressionStatement, fullStart);
                 expressionStatement.expression = expression;
                 parseSemicolon();
                 return finishNode(expressionStatement);
@@ -4504,9 +4503,9 @@ namespace ts {
         }
 
         function parseDeclaration(): Statement {
-            let fullStart = getNodePos();
-            let decorators = parseDecorators();
-            let modifiers = parseModifiers();
+            const fullStart = getNodePos();
+            const decorators = parseDecorators();
+            const modifiers = parseModifiers();
             switch (token) {
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
@@ -4536,7 +4535,7 @@ namespace ts {
                     if (decorators || modifiers) {
                         // We reached this point because we encountered decorators and/or modifiers and assumed a declaration
                         // would follow. For recovery and error reporting purposes, return an incomplete declaration.
-                        let node = <Statement>createMissingNode(SyntaxKind.MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected);
+                        const node = <Statement>createMissingNode(SyntaxKind.MissingDeclaration, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected);
                         node.pos = fullStart;
                         node.decorators = decorators;
                         setModifiers(node, modifiers);
@@ -4565,7 +4564,7 @@ namespace ts {
             if (token === SyntaxKind.CommaToken) {
                 return <BindingElement>createNode(SyntaxKind.OmittedExpression);
             }
-            let node = <BindingElement>createNode(SyntaxKind.BindingElement);
+            const node = <BindingElement>createNode(SyntaxKind.BindingElement);
             node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
             node.name = parseIdentifierOrPattern();
             node.initializer = parseBindingElementInitializer(/*inParameter*/ false);
@@ -4573,10 +4572,10 @@ namespace ts {
         }
 
         function parseObjectBindingElement(): BindingElement {
-            let node = <BindingElement>createNode(SyntaxKind.BindingElement);
+            const node = <BindingElement>createNode(SyntaxKind.BindingElement);
             // TODO(andersh): Handle computed properties
-            let tokenIsIdentifier = isIdentifier();
-            let propertyName = parsePropertyName();
+            const tokenIsIdentifier = isIdentifier();
+            const propertyName = parsePropertyName();
             if (tokenIsIdentifier && token !== SyntaxKind.ColonToken) {
                 node.name = <Identifier>propertyName;
             }
@@ -4590,7 +4589,7 @@ namespace ts {
         }
 
         function parseObjectBindingPattern(): BindingPattern {
-            let node = <BindingPattern>createNode(SyntaxKind.ObjectBindingPattern);
+            const node = <BindingPattern>createNode(SyntaxKind.ObjectBindingPattern);
             parseExpected(SyntaxKind.OpenBraceToken);
             node.elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement);
             parseExpected(SyntaxKind.CloseBraceToken);
@@ -4598,7 +4597,7 @@ namespace ts {
         }
 
         function parseArrayBindingPattern(): BindingPattern {
-            let node = <BindingPattern>createNode(SyntaxKind.ArrayBindingPattern);
+            const node = <BindingPattern>createNode(SyntaxKind.ArrayBindingPattern);
             parseExpected(SyntaxKind.OpenBracketToken);
             node.elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement);
             parseExpected(SyntaxKind.CloseBracketToken);
@@ -4620,7 +4619,7 @@ namespace ts {
         }
 
         function parseVariableDeclaration(): VariableDeclaration {
-            let node = <VariableDeclaration>createNode(SyntaxKind.VariableDeclaration);
+            const node = <VariableDeclaration>createNode(SyntaxKind.VariableDeclaration);
             node.name = parseIdentifierOrPattern();
             node.type = parseTypeAnnotation();
             if (!isInOrOfKeyword(token)) {
@@ -4630,7 +4629,7 @@ namespace ts {
         }
 
         function parseVariableDeclarationList(inForStatementInitializer: boolean): VariableDeclarationList {
-            let node = <VariableDeclarationList>createNode(SyntaxKind.VariableDeclarationList);
+            const node = <VariableDeclarationList>createNode(SyntaxKind.VariableDeclarationList);
 
             switch (token) {
                 case SyntaxKind.VarKeyword:
@@ -4660,7 +4659,7 @@ namespace ts {
                 node.declarations = createMissingList<VariableDeclaration>();
             }
             else {
-                let savedDisallowIn = inDisallowInContext();
+                const savedDisallowIn = inDisallowInContext();
                 setDisallowInContext(inForStatementInitializer);
 
                 node.declarations = parseDelimitedList(ParsingContext.VariableDeclarations, parseVariableDeclaration);
@@ -4676,7 +4675,7 @@ namespace ts {
         }
 
         function parseVariableStatement(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): VariableStatement {
-            let node = <VariableStatement>createNode(SyntaxKind.VariableStatement, fullStart);
+            const node = <VariableStatement>createNode(SyntaxKind.VariableStatement, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false);
@@ -4685,21 +4684,21 @@ namespace ts {
         }
 
         function parseFunctionDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): FunctionDeclaration {
-            let node = <FunctionDeclaration>createNode(SyntaxKind.FunctionDeclaration, fullStart);
+            const node = <FunctionDeclaration>createNode(SyntaxKind.FunctionDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.FunctionKeyword);
             node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
             node.name = node.flags & NodeFlags.Default ? parseOptionalIdentifier() : parseIdentifier();
-            let isGenerator = !!node.asteriskToken;
-            let isAsync = !!(node.flags & NodeFlags.Async);
+            const isGenerator = !!node.asteriskToken;
+            const isAsync = !!(node.flags & NodeFlags.Async);
             fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, node);
             node.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, Diagnostics.or_expected);
             return finishNode(node);
         }
 
         function parseConstructorDeclaration(pos: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ConstructorDeclaration {
-            let node = <ConstructorDeclaration>createNode(SyntaxKind.Constructor, pos);
+            const node = <ConstructorDeclaration>createNode(SyntaxKind.Constructor, pos);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ConstructorKeyword);
@@ -4709,21 +4708,21 @@ namespace ts {
         }
 
         function parseMethodDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, asteriskToken: Node, name: DeclarationName, questionToken: Node, diagnosticMessage?: DiagnosticMessage): MethodDeclaration {
-            let method = <MethodDeclaration>createNode(SyntaxKind.MethodDeclaration, fullStart);
+            const method = <MethodDeclaration>createNode(SyntaxKind.MethodDeclaration, fullStart);
             method.decorators = decorators;
             setModifiers(method, modifiers);
             method.asteriskToken = asteriskToken;
             method.name = name;
             method.questionToken = questionToken;
-            let isGenerator = !!asteriskToken;
-            let isAsync = !!(method.flags & NodeFlags.Async);
+            const isGenerator = !!asteriskToken;
+            const isAsync = !!(method.flags & NodeFlags.Async);
             fillSignature(SyntaxKind.ColonToken, /*yieldContext*/ isGenerator, /*awaitContext*/ isAsync, /*requireCompleteParameterList*/ false, method);
             method.body = parseFunctionBlockOrSemicolon(isGenerator, isAsync, diagnosticMessage);
             return finishNode(method);
         }
 
         function parsePropertyDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, name: DeclarationName, questionToken: Node): ClassElement {
-            let property = <PropertyDeclaration>createNode(SyntaxKind.PropertyDeclaration, fullStart);
+            const property = <PropertyDeclaration>createNode(SyntaxKind.PropertyDeclaration, fullStart);
             property.decorators = decorators;
             setModifiers(property, modifiers);
             property.name = name;
@@ -4748,12 +4747,12 @@ namespace ts {
         }
 
         function parsePropertyOrMethodDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ClassElement {
-            let asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
-            let name = parsePropertyName();
+            const asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);
+            const name = parsePropertyName();
 
             // Note: this is not legal as per the grammar.  But we allow it in the parser and
             // report an error in the grammar checker.
-            let questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
+            const questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
             if (asteriskToken || token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken) {
                 return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, name, questionToken, Diagnostics.or_expected);
             }
@@ -4767,7 +4766,7 @@ namespace ts {
         }
 
         function parseAccessorDeclaration(kind: SyntaxKind, fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): AccessorDeclaration {
-            let node = <AccessorDeclaration>createNode(kind, fullStart);
+            const node = <AccessorDeclaration>createNode(kind, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.name = parsePropertyName();
@@ -4859,7 +4858,7 @@ namespace ts {
         function parseDecorators(): NodeArray<Decorator> {
             let decorators: NodeArray<Decorator>;
             while (true) {
-                let decoratorStart = getNodePos();
+                const decoratorStart = getNodePos();
                 if (!parseOptional(SyntaxKind.AtToken)) {
                     break;
                 }
@@ -4869,7 +4868,7 @@ namespace ts {
                     decorators.pos = scanner.getStartPos();
                 }
 
-                let decorator = <Decorator>createNode(SyntaxKind.Decorator, decoratorStart);
+                const decorator = <Decorator>createNode(SyntaxKind.Decorator, decoratorStart);
                 decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher);
                 decorators.push(finishNode(decorator));
             }
@@ -4883,8 +4882,8 @@ namespace ts {
             let flags = 0;
             let modifiers: ModifiersArray;
             while (true) {
-                let modifierStart = scanner.getStartPos();
-                let modifierKind = token;
+                const modifierStart = scanner.getStartPos();
+                const modifierKind = token;
 
                 if (!parseAnyContextualModifier()) {
                     break;
@@ -4909,8 +4908,8 @@ namespace ts {
             let flags = 0;
             let modifiers: ModifiersArray;
             if (token === SyntaxKind.AsyncKeyword) {
-                let modifierStart = scanner.getStartPos();
-                let modifierKind = token;
+                const modifierStart = scanner.getStartPos();
+                const modifierKind = token;
                 nextToken();
                 modifiers = <ModifiersArray>[];
                 modifiers.pos = modifierStart;
@@ -4925,16 +4924,16 @@ namespace ts {
 
         function parseClassElement(): ClassElement {
             if (token === SyntaxKind.SemicolonToken) {
-                let result = <SemicolonClassElement>createNode(SyntaxKind.SemicolonClassElement);
+                const result = <SemicolonClassElement>createNode(SyntaxKind.SemicolonClassElement);
                 nextToken();
                 return finishNode(result);
             }
 
-            let fullStart = getNodePos();
-            let decorators = parseDecorators();
-            let modifiers = parseModifiers();
+            const fullStart = getNodePos();
+            const decorators = parseDecorators();
+            const modifiers = parseModifiers();
 
-            let accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
+            const accessor = tryParseAccessorDeclaration(fullStart, decorators, modifiers);
             if (accessor) {
                 return accessor;
             }
@@ -4960,7 +4959,7 @@ namespace ts {
 
             if (decorators || modifiers) {
                 // treat this as a property declaration with a missing name.
-                let name = <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected);
+                const name = <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition*/ true, Diagnostics.Declaration_expected);
                 return parsePropertyDeclaration(fullStart, decorators, modifiers, name, /*questionToken*/ undefined);
             }
 
@@ -4981,7 +4980,7 @@ namespace ts {
         }
 
         function parseClassDeclarationOrExpression(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, kind: SyntaxKind): ClassLikeDeclaration {
-            let node = <ClassLikeDeclaration>createNode(kind, fullStart);
+            const node = <ClassLikeDeclaration>createNode(kind, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.ClassKeyword);
@@ -5034,7 +5033,7 @@ namespace ts {
 
         function parseHeritageClause() {
             if (token === SyntaxKind.ExtendsKeyword || token === SyntaxKind.ImplementsKeyword) {
-                let node = <HeritageClause>createNode(SyntaxKind.HeritageClause);
+                const node = <HeritageClause>createNode(SyntaxKind.HeritageClause);
                 node.token = token;
                 nextToken();
                 node.types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseExpressionWithTypeArguments);
@@ -5045,7 +5044,7 @@ namespace ts {
         }
 
         function parseExpressionWithTypeArguments(): ExpressionWithTypeArguments {
-            let node = <ExpressionWithTypeArguments>createNode(SyntaxKind.ExpressionWithTypeArguments);
+            const node = <ExpressionWithTypeArguments>createNode(SyntaxKind.ExpressionWithTypeArguments);
             node.expression = parseLeftHandSideExpressionOrHigher();
             if (token === SyntaxKind.LessThanToken) {
                 node.typeArguments = parseBracketedList(ParsingContext.TypeArguments, parseType, SyntaxKind.LessThanToken, SyntaxKind.GreaterThanToken);
@@ -5063,7 +5062,7 @@ namespace ts {
         }
 
         function parseInterfaceDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): InterfaceDeclaration {
-            let node = <InterfaceDeclaration>createNode(SyntaxKind.InterfaceDeclaration, fullStart);
+            const node = <InterfaceDeclaration>createNode(SyntaxKind.InterfaceDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.InterfaceKeyword);
@@ -5075,7 +5074,7 @@ namespace ts {
         }
 
         function parseTypeAliasDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): TypeAliasDeclaration {
-            let node = <TypeAliasDeclaration>createNode(SyntaxKind.TypeAliasDeclaration, fullStart);
+            const node = <TypeAliasDeclaration>createNode(SyntaxKind.TypeAliasDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.TypeKeyword);
@@ -5092,14 +5091,14 @@ namespace ts {
         // ConstantEnumMemberSection, which starts at the beginning of an enum declaration
         // or any time an integer literal initializer is encountered.
         function parseEnumMember(): EnumMember {
-            let node = <EnumMember>createNode(SyntaxKind.EnumMember, scanner.getStartPos());
+            const node = <EnumMember>createNode(SyntaxKind.EnumMember, scanner.getStartPos());
             node.name = parsePropertyName();
             node.initializer = allowInAnd(parseNonParameterInitializer);
             return finishNode(node);
         }
 
         function parseEnumDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): EnumDeclaration {
-            let node = <EnumDeclaration>createNode(SyntaxKind.EnumDeclaration, fullStart);
+            const node = <EnumDeclaration>createNode(SyntaxKind.EnumDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             parseExpected(SyntaxKind.EnumKeyword);
@@ -5115,7 +5114,7 @@ namespace ts {
         }
 
         function parseModuleBlock(): ModuleBlock {
-            let node = <ModuleBlock>createNode(SyntaxKind.ModuleBlock, scanner.getStartPos());
+            const node = <ModuleBlock>createNode(SyntaxKind.ModuleBlock, scanner.getStartPos());
             if (parseExpected(SyntaxKind.OpenBraceToken)) {
                 node.statements = parseList(ParsingContext.BlockStatements, parseStatement);
                 parseExpected(SyntaxKind.CloseBraceToken);
@@ -5127,10 +5126,10 @@ namespace ts {
         }
 
         function parseModuleOrNamespaceDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray, flags: NodeFlags): ModuleDeclaration {
-            let node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
+            const node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
             // If we are parsing a dotted namespace name, we want to
             // propagate the 'Namespace' flag across the names if set.
-            let namespaceFlag = flags & NodeFlags.Namespace;
+            const namespaceFlag = flags & NodeFlags.Namespace;
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.flags |= flags;
@@ -5142,7 +5141,7 @@ namespace ts {
         }
 
         function parseAmbientExternalModuleDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ModuleDeclaration {
-            let node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
+            const node = <ModuleDeclaration>createNode(SyntaxKind.ModuleDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             node.name = parseLiteralNode(/*internName*/ true);
@@ -5185,7 +5184,7 @@ namespace ts {
 
         function parseImportDeclarationOrImportEqualsDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ImportEqualsDeclaration | ImportDeclaration {
             parseExpected(SyntaxKind.ImportKeyword);
-            let afterImportPos = scanner.getStartPos();
+            const afterImportPos = scanner.getStartPos();
 
             let identifier: Identifier;
             if (isIdentifier()) {
@@ -5194,7 +5193,7 @@ namespace ts {
                     // ImportEquals declaration of type:
                     // import x = require("mod"); or
                     // import x = M.x;
-                    let importEqualsDeclaration = <ImportEqualsDeclaration>createNode(SyntaxKind.ImportEqualsDeclaration, fullStart);
+                    const importEqualsDeclaration = <ImportEqualsDeclaration>createNode(SyntaxKind.ImportEqualsDeclaration, fullStart);
                     importEqualsDeclaration.decorators = decorators;
                     setModifiers(importEqualsDeclaration, modifiers);
                     importEqualsDeclaration.name = identifier;
@@ -5206,7 +5205,7 @@ namespace ts {
             }
 
             // Import statement
-            let importDeclaration = <ImportDeclaration>createNode(SyntaxKind.ImportDeclaration, fullStart);
+            const importDeclaration = <ImportDeclaration>createNode(SyntaxKind.ImportDeclaration, fullStart);
             importDeclaration.decorators = decorators;
             setModifiers(importDeclaration, modifiers);
 
@@ -5233,7 +5232,7 @@ namespace ts {
             //  ImportedDefaultBinding, NameSpaceImport
             //  ImportedDefaultBinding, NamedImports
 
-            let importClause = <ImportClause>createNode(SyntaxKind.ImportClause, fullStart);
+            const importClause = <ImportClause>createNode(SyntaxKind.ImportClause, fullStart);
             if (identifier) {
                 // ImportedDefaultBinding:
                 //  ImportedBinding
@@ -5257,7 +5256,7 @@ namespace ts {
         }
 
         function parseExternalModuleReference() {
-            let node = <ExternalModuleReference>createNode(SyntaxKind.ExternalModuleReference);
+            const node = <ExternalModuleReference>createNode(SyntaxKind.ExternalModuleReference);
             parseExpected(SyntaxKind.RequireKeyword);
             parseExpected(SyntaxKind.OpenParenToken);
             node.expression = parseModuleSpecifier();
@@ -5269,7 +5268,7 @@ namespace ts {
             // We allow arbitrary expressions here, even though the grammar only allows string
             // literals.  We check to ensure that it is only a string literal later in the grammar
             // walker.
-            let result = parseExpression();
+            const result = parseExpression();
             // Ensure the string being required is in our 'identifier' table.  This will ensure
             // that features like 'find refs' will look inside this file when search for its name.
             if (result.kind === SyntaxKind.StringLiteral) {
@@ -5281,7 +5280,7 @@ namespace ts {
         function parseNamespaceImport(): NamespaceImport {
             // NameSpaceImport:
             //  * as ImportedBinding
-            let namespaceImport = <NamespaceImport>createNode(SyntaxKind.NamespaceImport);
+            const namespaceImport = <NamespaceImport>createNode(SyntaxKind.NamespaceImport);
             parseExpected(SyntaxKind.AsteriskToken);
             parseExpected(SyntaxKind.AsKeyword);
             namespaceImport.name = parseIdentifier();
@@ -5289,7 +5288,7 @@ namespace ts {
         }
 
         function parseNamedImportsOrExports(kind: SyntaxKind): NamedImportsOrExports {
-            let node = <NamedImports>createNode(kind);
+            const node = <NamedImports>createNode(kind);
 
             // NamedImports:
             //  { }
@@ -5314,7 +5313,7 @@ namespace ts {
         }
 
         function parseImportOrExportSpecifier(kind: SyntaxKind): ImportOrExportSpecifier {
-            let node = <ImportSpecifier>createNode(kind);
+            const node = <ImportSpecifier>createNode(kind);
             // ImportSpecifier:
             //   BindingIdentifier
             //   IdentifierName as BindingIdentifier
@@ -5324,7 +5323,7 @@ namespace ts {
             let checkIdentifierIsKeyword = isKeyword(token) && !isIdentifier();
             let checkIdentifierStart = scanner.getTokenPos();
             let checkIdentifierEnd = scanner.getTextPos();
-            let identifierName = parseIdentifierName();
+            const identifierName = parseIdentifierName();
             if (token === SyntaxKind.AsKeyword) {
                 node.propertyName = identifierName;
                 parseExpected(SyntaxKind.AsKeyword);
@@ -5344,7 +5343,7 @@ namespace ts {
         }
 
         function parseExportDeclaration(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ExportDeclaration {
-            let node = <ExportDeclaration>createNode(SyntaxKind.ExportDeclaration, fullStart);
+            const node = <ExportDeclaration>createNode(SyntaxKind.ExportDeclaration, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             if (parseOptional(SyntaxKind.AsteriskToken)) {
@@ -5367,7 +5366,7 @@ namespace ts {
         }
 
         function parseExportAssignment(fullStart: number, decorators: NodeArray<Decorator>, modifiers: ModifiersArray): ExportAssignment {
-            let node = <ExportAssignment>createNode(SyntaxKind.ExportAssignment, fullStart);
+            const node = <ExportAssignment>createNode(SyntaxKind.ExportAssignment, fullStart);
             node.decorators = decorators;
             setModifiers(node, modifiers);
             if (parseOptional(SyntaxKind.EqualsToken)) {
@@ -5382,16 +5381,16 @@ namespace ts {
         }
 
         function processReferenceComments(sourceFile: SourceFile): void {
-            let triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, LanguageVariant.Standard, sourceText);
-            let referencedFiles: FileReference[] = [];
-            let amdDependencies: { path: string; name: string }[] = [];
+            const triviaScanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/false, LanguageVariant.Standard, sourceText);
+            const referencedFiles: FileReference[] = [];
+            const amdDependencies: { path: string; name: string }[] = [];
             let amdModuleName: string;
 
             // Keep scanning all the leading trivia in the file until we get to something that
             // isn't trivia.  Any single line comment will be analyzed to see if it is a
             // reference comment.
             while (true) {
-                let kind = triviaScanner.scan();
+                const kind = triviaScanner.scan();
                 if (kind === SyntaxKind.WhitespaceTrivia || kind === SyntaxKind.NewLineTrivia || kind === SyntaxKind.MultiLineCommentTrivia) {
                     continue;
                 }
@@ -5399,14 +5398,14 @@ namespace ts {
                     break;
                 }
 
-                let range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() };
+                const range = { pos: triviaScanner.getTokenPos(), end: triviaScanner.getTextPos(), kind: triviaScanner.getToken() };
 
-                let comment = sourceText.substring(range.pos, range.end);
-                let referencePathMatchResult = getFileReferenceFromReferencePath(comment, range);
+                const comment = sourceText.substring(range.pos, range.end);
+                const referencePathMatchResult = getFileReferenceFromReferencePath(comment, range);
                 if (referencePathMatchResult) {
-                    let fileReference = referencePathMatchResult.fileReference;
+                    const fileReference = referencePathMatchResult.fileReference;
                     sourceFile.hasNoDefaultLib = referencePathMatchResult.isNoDefaultLib;
-                    let diagnosticMessage = referencePathMatchResult.diagnosticMessage;
+                    const diagnosticMessage = referencePathMatchResult.diagnosticMessage;
                     if (fileReference) {
                         referencedFiles.push(fileReference);
                     }
@@ -5415,8 +5414,8 @@ namespace ts {
                     }
                 }
                 else {
-                    let amdModuleNameRegEx = /^\/\/\/\s*<amd-module\s+name\s*=\s*('|")(.+?)\1/gim;
-                    let amdModuleNameMatchResult = amdModuleNameRegEx.exec(comment);
+                    const amdModuleNameRegEx = /^\/\/\/\s*<amd-module\s+name\s*=\s*('|")(.+?)\1/gim;
+                    const amdModuleNameMatchResult = amdModuleNameRegEx.exec(comment);
                     if (amdModuleNameMatchResult) {
                         if (amdModuleName) {
                             parseDiagnostics.push(createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments));
@@ -5424,15 +5423,15 @@ namespace ts {
                         amdModuleName = amdModuleNameMatchResult[2];
                     }
 
-                    let amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s/gim;
-                    let pathRegex = /\spath\s*=\s*('|")(.+?)\1/gim;
-                    let nameRegex = /\sname\s*=\s*('|")(.+?)\1/gim;
-                    let amdDependencyMatchResult = amdDependencyRegEx.exec(comment);
+                    const amdDependencyRegEx = /^\/\/\/\s*<amd-dependency\s/gim;
+                    const pathRegex = /\spath\s*=\s*('|")(.+?)\1/gim;
+                    const nameRegex = /\sname\s*=\s*('|")(.+?)\1/gim;
+                    const amdDependencyMatchResult = amdDependencyRegEx.exec(comment);
                     if (amdDependencyMatchResult) {
-                        let pathMatchResult = pathRegex.exec(comment);
-                        let nameMatchResult = nameRegex.exec(comment);
+                        const pathMatchResult = pathRegex.exec(comment);
+                        const nameMatchResult = nameRegex.exec(comment);
                         if (pathMatchResult) {
-                            let amdDependency = { path: pathMatchResult[2], name: nameMatchResult ? nameMatchResult[2] : undefined };
+                            const amdDependency = { path: pathMatchResult[2], name: nameMatchResult ? nameMatchResult[2] : undefined };
                             amdDependencies.push(amdDependency);
                         }
                     }
@@ -5512,8 +5511,8 @@ namespace ts {
 
             export function parseJSDocTypeExpressionForTests(content: string, start: number, length: number) {
                 initializeState("file.js", content, ScriptTarget.Latest, /*_syntaxCursor:*/ undefined);
-                let jsDocTypeExpression = parseJSDocTypeExpression(start, length);
-                let diagnostics = parseDiagnostics;
+                const jsDocTypeExpression = parseJSDocTypeExpression(start, length);
+                const diagnostics = parseDiagnostics;
                 clearState();
 
                 return jsDocTypeExpression ? { jsDocTypeExpression, diagnostics } : undefined;
@@ -5528,7 +5527,7 @@ namespace ts {
                 // Prime the first token for us to start processing.
                 token = nextToken();
 
-                let result = <JSDocTypeExpression>createNode(SyntaxKind.JSDocTypeExpression);
+                const result = <JSDocTypeExpression>createNode(SyntaxKind.JSDocTypeExpression);
 
                 parseExpected(SyntaxKind.OpenBraceToken);
                 result.type = parseJSDocTopLevelType();
@@ -5541,13 +5540,13 @@ namespace ts {
             function parseJSDocTopLevelType(): JSDocType {
                 let type = parseJSDocType();
                 if (token === SyntaxKind.BarToken) {
-                    let unionType = <JSDocUnionType>createNode(SyntaxKind.JSDocUnionType, type.pos);
+                    const unionType = <JSDocUnionType>createNode(SyntaxKind.JSDocUnionType, type.pos);
                     unionType.types = parseJSDocTypeList(type);
                     type = finishNode(unionType);
                 }
 
                 if (token === SyntaxKind.EqualsToken) {
-                    let optionalType = <JSDocOptionalType>createNode(SyntaxKind.JSDocOptionalType, type.pos);
+                    const optionalType = <JSDocOptionalType>createNode(SyntaxKind.JSDocOptionalType, type.pos);
                     nextToken();
                     optionalType.type = type;
                     type = finishNode(optionalType);
@@ -5561,7 +5560,7 @@ namespace ts {
 
                 while (true) {
                     if (token === SyntaxKind.OpenBracketToken) {
-                        let arrayType = <JSDocArrayType>createNode(SyntaxKind.JSDocArrayType, type.pos);
+                        const arrayType = <JSDocArrayType>createNode(SyntaxKind.JSDocArrayType, type.pos);
                         arrayType.elementType = type;
 
                         nextToken();
@@ -5570,14 +5569,14 @@ namespace ts {
                         type = finishNode(arrayType);
                     }
                     else if (token === SyntaxKind.QuestionToken) {
-                        let nullableType = <JSDocNullableType>createNode(SyntaxKind.JSDocNullableType, type.pos);
+                        const nullableType = <JSDocNullableType>createNode(SyntaxKind.JSDocNullableType, type.pos);
                         nullableType.type = type;
 
                         nextToken();
                         type = finishNode(nullableType);
                     }
                     else if (token === SyntaxKind.ExclamationToken) {
-                        let nonNullableType = <JSDocNonNullableType>createNode(SyntaxKind.JSDocNonNullableType, type.pos);
+                        const nonNullableType = <JSDocNonNullableType>createNode(SyntaxKind.JSDocNonNullableType, type.pos);
                         nonNullableType.type = type;
 
                         nextToken();
@@ -5626,7 +5625,7 @@ namespace ts {
             }
 
             function parseJSDocThisType(): JSDocThisType {
-                let result = <JSDocThisType>createNode(SyntaxKind.JSDocThisType);
+                const result = <JSDocThisType>createNode(SyntaxKind.JSDocThisType);
                 nextToken();
                 parseExpected(SyntaxKind.ColonToken);
                 result.type = parseJSDocType();
@@ -5634,7 +5633,7 @@ namespace ts {
             }
 
             function parseJSDocConstructorType(): JSDocConstructorType {
-                let result = <JSDocConstructorType>createNode(SyntaxKind.JSDocConstructorType);
+                const result = <JSDocConstructorType>createNode(SyntaxKind.JSDocConstructorType);
                 nextToken();
                 parseExpected(SyntaxKind.ColonToken);
                 result.type = parseJSDocType();
@@ -5642,14 +5641,14 @@ namespace ts {
             }
 
             function parseJSDocVariadicType(): JSDocVariadicType {
-                let result = <JSDocVariadicType>createNode(SyntaxKind.JSDocVariadicType);
+                const result = <JSDocVariadicType>createNode(SyntaxKind.JSDocVariadicType);
                 nextToken();
                 result.type = parseJSDocType();
                 return finishNode(result);
             }
 
             function parseJSDocFunctionType(): JSDocFunctionType {
-                let result = <JSDocFunctionType>createNode(SyntaxKind.JSDocFunctionType);
+                const result = <JSDocFunctionType>createNode(SyntaxKind.JSDocFunctionType);
                 nextToken();
 
                 parseExpected(SyntaxKind.OpenParenToken);
@@ -5666,20 +5665,20 @@ namespace ts {
             }
 
             function parseJSDocParameter(): ParameterDeclaration {
-                let parameter = <ParameterDeclaration>createNode(SyntaxKind.Parameter);
+                const parameter = <ParameterDeclaration>createNode(SyntaxKind.Parameter);
                 parameter.type = parseJSDocType();
                 return finishNode(parameter);
             }
 
             function parseJSDocOptionalType(type: JSDocType): JSDocOptionalType {
-                let result = <JSDocOptionalType>createNode(SyntaxKind.JSDocOptionalType, type.pos);
+                const result = <JSDocOptionalType>createNode(SyntaxKind.JSDocOptionalType, type.pos);
                 nextToken();
                 result.type = type;
                 return finishNode(result);
             }
 
             function parseJSDocTypeReference(): JSDocTypeReference {
-                let result = <JSDocTypeReference>createNode(SyntaxKind.JSDocTypeReference);
+                const result = <JSDocTypeReference>createNode(SyntaxKind.JSDocTypeReference);
                 result.name = parseSimplePropertyName();
 
                 while (parseOptional(SyntaxKind.DotToken)) {
@@ -5698,7 +5697,7 @@ namespace ts {
             function parseTypeArguments() {
                 // Move past the <
                 nextToken();
-                let typeArguments = parseDelimitedList(ParsingContext.JSDocTypeArguments, parseJSDocType);
+                const typeArguments = parseDelimitedList(ParsingContext.JSDocTypeArguments, parseJSDocType);
                 checkForTrailingComma(typeArguments);
                 checkForEmptyTypeArgumentList(typeArguments);
                 parseExpected(SyntaxKind.GreaterThanToken);
@@ -5708,14 +5707,14 @@ namespace ts {
 
             function checkForEmptyTypeArgumentList(typeArguments: NodeArray<Node>) {
                 if (parseDiagnostics.length === 0 &&  typeArguments && typeArguments.length === 0) {
-                    let start = typeArguments.pos - "<".length;
-                    let end = skipTrivia(sourceText, typeArguments.end) + ">".length;
+                    const start = typeArguments.pos - "<".length;
+                    const end = skipTrivia(sourceText, typeArguments.end) + ">".length;
                     return parseErrorAtPosition(start, end - start, Diagnostics.Type_argument_list_cannot_be_empty);
                 }
             }
 
             function parseQualifiedName(left: EntityName): QualifiedName {
-                let result = <QualifiedName>createNode(SyntaxKind.QualifiedName, left.pos);
+                const result = <QualifiedName>createNode(SyntaxKind.QualifiedName, left.pos);
                 result.left = left;
                 result.right = parseIdentifierName();
 
@@ -5723,7 +5722,7 @@ namespace ts {
             }
 
             function parseJSDocRecordType(): JSDocRecordType {
-                let result = <JSDocRecordType>createNode(SyntaxKind.JSDocRecordType);
+                const result = <JSDocRecordType>createNode(SyntaxKind.JSDocRecordType);
                 nextToken();
                 result.members = parseDelimitedList(ParsingContext.JSDocRecordMembers, parseJSDocRecordMember);
                 checkForTrailingComma(result.members);
@@ -5732,7 +5731,7 @@ namespace ts {
             }
 
             function parseJSDocRecordMember(): JSDocRecordMember {
-                let result = <JSDocRecordMember>createNode(SyntaxKind.JSDocRecordMember);
+                const result = <JSDocRecordMember>createNode(SyntaxKind.JSDocRecordMember);
                 result.name = parseSimplePropertyName();
 
                 if (token === SyntaxKind.ColonToken) {
@@ -5744,14 +5743,14 @@ namespace ts {
             }
 
             function parseJSDocNonNullableType(): JSDocNonNullableType {
-                let result = <JSDocNonNullableType>createNode(SyntaxKind.JSDocNonNullableType);
+                const result = <JSDocNonNullableType>createNode(SyntaxKind.JSDocNonNullableType);
                 nextToken();
                 result.type = parseJSDocType();
                 return finishNode(result);
             }
 
             function parseJSDocTupleType(): JSDocTupleType {
-                let result = <JSDocTupleType>createNode(SyntaxKind.JSDocTupleType);
+                const result = <JSDocTupleType>createNode(SyntaxKind.JSDocTupleType);
                 nextToken();
                 result.types = parseDelimitedList(ParsingContext.JSDocTupleTypes, parseJSDocType);
                 checkForTrailingComma(result.types);
@@ -5762,13 +5761,13 @@ namespace ts {
 
             function checkForTrailingComma(list: NodeArray<Node>) {
                 if (parseDiagnostics.length === 0 && list.hasTrailingComma) {
-                    let start = list.end - ",".length;
+                    const start = list.end - ",".length;
                     parseErrorAtPosition(start, ",".length, Diagnostics.Trailing_comma_not_allowed);
                 }
             }
 
             function parseJSDocUnionType(): JSDocUnionType {
-                let result = <JSDocUnionType>createNode(SyntaxKind.JSDocUnionType);
+                const result = <JSDocUnionType>createNode(SyntaxKind.JSDocUnionType);
                 nextToken();
                 result.types = parseJSDocTypeList(parseJSDocType());
 
@@ -5780,7 +5779,7 @@ namespace ts {
             function parseJSDocTypeList(firstType: JSDocType) {
                 Debug.assert(!!firstType);
 
-                let types = <NodeArray<JSDocType>>[];
+                const types = <NodeArray<JSDocType>>[];
                 types.pos = firstType.pos;
 
                 types.push(firstType);
@@ -5793,13 +5792,13 @@ namespace ts {
             }
 
             function parseJSDocAllType(): JSDocAllType {
-                let result = <JSDocAllType>createNode(SyntaxKind.JSDocAllType);
+                const result = <JSDocAllType>createNode(SyntaxKind.JSDocAllType);
                 nextToken();
                 return finishNode(result);
             }
 
             function parseJSDocUnknownOrNullableType(): JSDocUnknownType | JSDocNullableType {
-                let pos = scanner.getStartPos();
+                const pos = scanner.getStartPos();
                 // skip the ?
                 nextToken();
 
@@ -5820,11 +5819,11 @@ namespace ts {
                     token === SyntaxKind.EqualsToken ||
                     token === SyntaxKind.BarToken) {
 
-                    let result = <JSDocUnknownType>createNode(SyntaxKind.JSDocUnknownType, pos);
+                    const result = <JSDocUnknownType>createNode(SyntaxKind.JSDocUnknownType, pos);
                     return finishNode(result);
                 }
                 else {
-                    let result = <JSDocNullableType>createNode(SyntaxKind.JSDocNullableType, pos);
+                    const result = <JSDocNullableType>createNode(SyntaxKind.JSDocNullableType, pos);
                     result.type = parseJSDocType();
                     return finishNode(result);
                 }
@@ -5832,15 +5831,15 @@ namespace ts {
 
             export function parseIsolatedJSDocComment(content: string, start: number, length: number) {
                 initializeState("file.js", content, ScriptTarget.Latest, /*_syntaxCursor:*/ undefined);
-                let jsDocComment = parseJSDocComment(/*parent:*/ undefined, start, length);
-                let diagnostics = parseDiagnostics;
+                const jsDocComment = parseJSDocComment(/*parent:*/ undefined, start, length);
+                const diagnostics = parseDiagnostics;
                 clearState();
 
                 return jsDocComment ? { jsDocComment, diagnostics } : undefined;
             }
 
             export function parseJSDocComment(parent: Node, start: number, length: number): JSDocComment {
-                let comment = parseJSDocCommentWorker(start, length);
+                const comment = parseJSDocCommentWorker(start, length);
                 if (comment) {
                     fixupParentReferences(comment);
                     comment.parent = parent;
@@ -5850,9 +5849,9 @@ namespace ts {
             }
 
             export function parseJSDocCommentWorker(start: number, length: number): JSDocComment {
-                let content = sourceText;
+                const content = sourceText;
                 start = start || 0;
-                let end = length === undefined ? content.length : start + length;
+                const end = length === undefined ? content.length : start + length;
                 length = end - start;
 
                 Debug.assert(start >= 0);
@@ -5879,7 +5878,7 @@ namespace ts {
                         let seenAsterisk = true;
 
                         for (pos = start + "/**".length; pos < end; ) {
-                            let ch = content.charCodeAt(pos);
+                            const ch = content.charCodeAt(pos);
                             pos++;
 
                             if (ch === CharacterCodes.at && canParseTag) {
@@ -5929,7 +5928,7 @@ namespace ts {
                         return undefined;
                     }
 
-                    let result = <JSDocComment>createNode(SyntaxKind.JSDocComment, start);
+                    const result = <JSDocComment>createNode(SyntaxKind.JSDocComment, start);
                     result.tags = tags;
                     return finishNode(result, end);
                 }
@@ -5942,15 +5941,15 @@ namespace ts {
 
                 function parseTag(): void {
                     Debug.assert(content.charCodeAt(pos - 1) === CharacterCodes.at);
-                    let atToken = createNode(SyntaxKind.AtToken, pos - 1);
+                    const atToken = createNode(SyntaxKind.AtToken, pos - 1);
                     atToken.end = pos;
 
-                    let tagName = scanIdentifier();
+                    const tagName = scanIdentifier();
                     if (!tagName) {
                         return;
                     }
 
-                    let tag = handleTag(atToken, tagName) || handleUnknownTag(atToken, tagName);
+                    const tag = handleTag(atToken, tagName) || handleUnknownTag(atToken, tagName);
                     addTag(tag);
                 }
 
@@ -5973,7 +5972,7 @@ namespace ts {
                 }
 
                 function handleUnknownTag(atToken: Node, tagName: Identifier) {
-                    let result = <JSDocTag>createNode(SyntaxKind.JSDocTag, atToken.pos);
+                    const result = <JSDocTag>createNode(SyntaxKind.JSDocTag, atToken.pos);
                     result.atToken = atToken;
                     result.tagName = tagName;
                     return finishNode(result, pos);
@@ -5998,7 +5997,7 @@ namespace ts {
                         return undefined;
                     }
 
-                    let typeExpression = parseJSDocTypeExpression(pos, end - pos);
+                    const typeExpression = parseJSDocTypeExpression(pos, end - pos);
                     pos = typeExpression.end;
                     return typeExpression;
                 }
@@ -6035,7 +6034,7 @@ namespace ts {
                         typeExpression = tryParseTypeExpression();
                     }
 
-                    let result = <JSDocParameterTag>createNode(SyntaxKind.JSDocParameterTag, atToken.pos);
+                    const result = <JSDocParameterTag>createNode(SyntaxKind.JSDocParameterTag, atToken.pos);
                     result.atToken = atToken;
                     result.tagName = tagName;
                     result.preParameterName = preName;
@@ -6050,7 +6049,7 @@ namespace ts {
                         parseErrorAtPosition(tagName.pos, pos - tagName.pos, Diagnostics._0_tag_already_specified, tagName.text);
                     }
 
-                    let result = <JSDocReturnTag>createNode(SyntaxKind.JSDocReturnTag, atToken.pos);
+                    const result = <JSDocReturnTag>createNode(SyntaxKind.JSDocReturnTag, atToken.pos);
                     result.atToken = atToken;
                     result.tagName = tagName;
                     result.typeExpression = tryParseTypeExpression();
@@ -6062,7 +6061,7 @@ namespace ts {
                         parseErrorAtPosition(tagName.pos, pos - tagName.pos, Diagnostics._0_tag_already_specified, tagName.text);
                     }
 
-                    let result = <JSDocTypeTag>createNode(SyntaxKind.JSDocTypeTag, atToken.pos);
+                    const result = <JSDocTypeTag>createNode(SyntaxKind.JSDocTypeTag, atToken.pos);
                     result.atToken = atToken;
                     result.tagName = tagName;
                     result.typeExpression = tryParseTypeExpression();
@@ -6074,20 +6073,20 @@ namespace ts {
                         parseErrorAtPosition(tagName.pos, pos - tagName.pos, Diagnostics._0_tag_already_specified, tagName.text);
                     }
 
-                    let typeParameters = <NodeArray<TypeParameterDeclaration>>[];
+                    const typeParameters = <NodeArray<TypeParameterDeclaration>>[];
                     typeParameters.pos = pos;
 
                     while (true) {
                         skipWhitespace();
 
-                        let startPos = pos;
-                        let name = scanIdentifier();
+                        const startPos = pos;
+                        const name = scanIdentifier();
                         if (!name) {
                             parseErrorAtPosition(startPos, 0, Diagnostics.Identifier_expected);
                             return undefined;
                         }
 
-                        let typeParameter = <TypeParameterDeclaration>createNode(SyntaxKind.TypeParameter, name.pos);
+                        const typeParameter = <TypeParameterDeclaration>createNode(SyntaxKind.TypeParameter, name.pos);
                         typeParameter.name = name;
                         finishNode(typeParameter, pos);
 
@@ -6103,7 +6102,7 @@ namespace ts {
 
                     typeParameters.end = pos;
 
-                    let result = <JSDocTemplateTag>createNode(SyntaxKind.JSDocTemplateTag, atToken.pos);
+                    const result = <JSDocTemplateTag>createNode(SyntaxKind.JSDocTemplateTag, atToken.pos);
                     result.atToken = atToken;
                     result.tagName = tagName;
                     result.typeParameters = typeParameters;
@@ -6111,9 +6110,9 @@ namespace ts {
                 }
 
                 function scanIdentifier(): Identifier {
-                    let startPos = pos;
+                    const startPos = pos;
                     for (; pos < end; pos++) {
-                        let ch = content.charCodeAt(pos);
+                        const ch = content.charCodeAt(pos);
                         if (pos === startPos && isIdentifierStart(ch, ScriptTarget.Latest)) {
                             continue;
                         }
@@ -6128,7 +6127,7 @@ namespace ts {
                         return undefined;
                     }
 
-                    let result = <Identifier>createNode(SyntaxKind.Identifier, startPos);
+                    const result = <Identifier>createNode(SyntaxKind.Identifier, startPos);
                     result.text = content.substring(startPos, pos);
                     return finishNode(result, pos);
                 }
@@ -6158,16 +6157,16 @@ namespace ts {
             // This is because we do incremental parsing in-place.  i.e. we take nodes from the old
             // tree and give them new positions and parents.  From that point on, trusting the old
             // tree at all is not possible as far too much of it may violate invariants.
-            let incrementalSourceFile = <IncrementalNode><Node>sourceFile;
+            const incrementalSourceFile = <IncrementalNode><Node>sourceFile;
             Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed);
             incrementalSourceFile.hasBeenIncrementallyParsed = true;
 
-            let oldText = sourceFile.text;
-            let syntaxCursor = createSyntaxCursor(sourceFile);
+            const oldText = sourceFile.text;
+            const syntaxCursor = createSyntaxCursor(sourceFile);
 
             // Make the actual change larger so that we know to reparse anything whose lookahead
             // might have intersected the change.
-            let changeRange = extendToAffectedRange(sourceFile, textChangeRange);
+            const changeRange = extendToAffectedRange(sourceFile, textChangeRange);
             checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks);
 
             // Ensure that extending the affected range only moved the start of the change range
@@ -6179,7 +6178,7 @@ namespace ts {
             // The is the amount the nodes after the edit range need to be adjusted.  It can be
             // positive (if the edit added characters), negative (if the edit deleted characters)
             // or zero (if this was a pure overwrite with nothing added/removed).
-            let delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
+            const delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
 
             // If we added or removed characters during the edit, then we need to go and adjust all
             // the nodes after the edit.  Those nodes may move forward (if we inserted chars) or they
@@ -6213,7 +6212,7 @@ namespace ts {
             // inconsistent tree.  Setting the parents on the new tree should be very fast.  We
             // will immediately bail out of walking any subtrees when we can see that their parents
             // are already correct.
-            let result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true);
+            const result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true);
 
             return result;
         }
@@ -6259,7 +6258,7 @@ namespace ts {
                 array.pos += delta;
                 array.end += delta;
 
-                for (let node of array) {
+                for (const node of array) {
                     visitNode(node);
                 }
             }
@@ -6387,7 +6386,7 @@ namespace ts {
                 // Check if the element intersects the change range.  If it does, then it is not
                 // reusable.  Also, we'll need to recurse to see what constituent portions we may
                 // be able to use.
-                let fullEnd = child.end;
+                const fullEnd = child.end;
                 if (fullEnd >= changeStart) {
                     child.intersectsChange = true;
                     child._children = undefined;
@@ -6416,14 +6415,14 @@ namespace ts {
                 // Check if the element intersects the change range.  If it does, then it is not
                 // reusable.  Also, we'll need to recurse to see what constituent portions we may
                 // be able to use.
-                let fullEnd = array.end;
+                const fullEnd = array.end;
                 if (fullEnd >= changeStart) {
                     array.intersectsChange = true;
                     array._children = undefined;
 
                     // Adjust the pos or end (or both) of the intersecting array accordingly.
                     adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
-                    for (let node of array) {
+                    for (const node of array) {
                         visitNode(node);
                     }
                     return;
@@ -6445,7 +6444,7 @@ namespace ts {
             // (as it does not intersect the actual original change range).  Because an edit may
             // change the token touching it, we actually need to look back *at least* one token so
             // that the prior token sees that change.
-            let maxLookahead = 1;
+            const maxLookahead = 1;
 
             let start = changeRange.span.start;
 
@@ -6453,15 +6452,15 @@ namespace ts {
             // the left by maxLookahead tokens.  We only need to do this as long as we're not at the
             // start of the tree.
             for (let i = 0; start > 0 && i <= maxLookahead; i++) {
-                let nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start);
+                const nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start);
                 Debug.assert(nearestNode.pos <= start);
-                let position = nearestNode.pos;
+                const position = nearestNode.pos;
 
                 start = Math.max(0, position - 1);
             }
 
-            let finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span));
-            let finalLength = changeRange.newLength + (changeRange.span.start - start);
+            const finalSpan = createTextSpanFromBounds(start, textSpanEnd(changeRange.span));
+            const finalLength = changeRange.newLength + (changeRange.span.start - start);
 
             return createTextChangeRange(finalSpan, finalLength);
         }
@@ -6473,7 +6472,7 @@ namespace ts {
             forEachChild(sourceFile, visit);
 
             if (lastNodeEntirelyBeforePosition) {
-                let lastChildOfLastEntireNodeBeforePosition = getLastChild(lastNodeEntirelyBeforePosition);
+                const lastChildOfLastEntireNodeBeforePosition = getLastChild(lastNodeEntirelyBeforePosition);
                 if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) {
                     bestResult = lastChildOfLastEntireNodeBeforePosition;
                 }
@@ -6483,7 +6482,7 @@ namespace ts {
 
             function getLastChild(node: Node): Node {
                 while (true) {
-                    let lastChild = getLastChildWorker(node);
+                    const lastChild = getLastChildWorker(node);
                     if (lastChild) {
                         node = lastChild;
                     }
@@ -6562,17 +6561,17 @@ namespace ts {
         }
 
         function checkChangeRange(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks: boolean) {
-            let oldText = sourceFile.text;
+            const oldText = sourceFile.text;
             if (textChangeRange) {
                 Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length);
 
                 if (aggressiveChecks || Debug.shouldAssert(AssertionLevel.VeryAggressive)) {
-                    let oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
-                    let newTextPrefix = newText.substr(0, textChangeRange.span.start);
+                    const oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
+                    const newTextPrefix = newText.substr(0, textChangeRange.span.start);
                     Debug.assert(oldTextPrefix === newTextPrefix);
 
-                    let oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length);
-                    let newTextSuffix = newText.substring(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.length);
+                    const oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length);
+                    const newTextSuffix = newText.substring(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.length);
                     Debug.assert(oldTextSuffix === newTextSuffix);
                 }
             }
@@ -6674,7 +6673,7 @@ namespace ts {
                         // position was in this array.  Search through this array to see if we find a
                         // viable element.
                         for (let i = 0, n = array.length; i < n; i++) {
-                            let child = array[i];
+                            const child = array[i];
                             if (child) {
                                 if (child.pos === position) {
                                     // Found the right node.  We're done.
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 254f6b1fe3b..8f807ed7b86 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -10,7 +10,7 @@ namespace ts {
 
     /** The version of the TypeScript compiler release */
 
-    let emptyArray: any[] = [];
+    const emptyArray: any[] = [];
 
     export const version = "1.8.0";
 
@@ -20,7 +20,7 @@ namespace ts {
             if (fileExists(fileName)) {
                 return fileName;
             }
-            let parentPath = getDirectoryPath(searchPath);
+            const parentPath = getDirectoryPath(searchPath);
             if (parentPath === searchPath) {
                 break;
             }
@@ -31,13 +31,13 @@ namespace ts {
     }
 
     export function resolveTripleslashReference(moduleName: string, containingFile: string): string {
-        let basePath = getDirectoryPath(containingFile);
-        let referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);
+        const basePath = getDirectoryPath(containingFile);
+        const referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);
         return normalizePath(referencedFileName);
     }
 
     export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
-        let moduleResolution = compilerOptions.moduleResolution !== undefined
+        const moduleResolution = compilerOptions.moduleResolution !== undefined
             ? compilerOptions.moduleResolution
             : compilerOptions.module === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic;
 
@@ -48,11 +48,11 @@ namespace ts {
     }
 
     export function nodeModuleNameResolver(moduleName: string, containingFile: string, supportedExtensions: string[], host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
-        let containingDirectory = getDirectoryPath(containingFile);
+        const containingDirectory = getDirectoryPath(containingFile);
 
         if (getRootLength(moduleName) !== 0 || nameStartsWithDotSlashOrDotDotSlash(moduleName)) {
-            let failedLookupLocations: string[] = [];
-            let candidate = normalizePath(combinePaths(containingDirectory, moduleName));
+            const failedLookupLocations: string[] = [];
+            const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
             let resolvedFileName = loadNodeModuleFromFile(candidate, supportedExtensions, failedLookupLocations, host);
 
             if (resolvedFileName) {
@@ -73,7 +73,7 @@ namespace ts {
         return forEach(supportedExtensions, tryLoad);
 
         function tryLoad(ext: string): string {
-            let fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
+            const fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
             if (host.fileExists(fileName)) {
                 return fileName;
             }
@@ -85,13 +85,13 @@ namespace ts {
     }
 
     function loadNodeModuleFromDirectory(candidate: string, supportedExtensions: string[], failedLookupLocation: string[], host: ModuleResolutionHost): string {
-        let packageJsonPath = combinePaths(candidate, "package.json");
+        const packageJsonPath = combinePaths(candidate, "package.json");
         if (host.fileExists(packageJsonPath)) {
 
             let jsonContent: { typings?: string };
 
             try {
-                let jsonText = host.readFile(packageJsonPath);
+                const jsonText = host.readFile(packageJsonPath);
                 jsonContent = jsonText ? <{ typings?: string }>JSON.parse(jsonText) : { typings: undefined };
             }
             catch (e) {
@@ -100,7 +100,7 @@ namespace ts {
             }
 
             if (jsonContent.typings) {
-                let result = loadNodeModuleFromFile(normalizePath(combinePaths(candidate, jsonContent.typings)), supportedExtensions, failedLookupLocation, host);
+                const result = loadNodeModuleFromFile(normalizePath(combinePaths(candidate, jsonContent.typings)), supportedExtensions, failedLookupLocation, host);
                 if (result) {
                     return result;
                 }
@@ -115,13 +115,13 @@ namespace ts {
     }
 
     function loadModuleFromNodeModules(moduleName: string, directory: string, supportedExtensions: string[], host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
-        let failedLookupLocations: string[] = [];
+        const failedLookupLocations: string[] = [];
         directory = normalizeSlashes(directory);
         while (true) {
-            let baseName = getBaseFileName(directory);
+            const baseName = getBaseFileName(directory);
             if (baseName !== "node_modules") {
-                let nodeModulesFolder = combinePaths(directory, "node_modules");
-                let candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
+                const nodeModulesFolder = combinePaths(directory, "node_modules");
+                const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
                 let result = loadNodeModuleFromFile(candidate, supportedExtensions, failedLookupLocations, host);
                 if (result) {
                     return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };
@@ -133,7 +133,7 @@ namespace ts {
                 }
             }
 
-            let parentPath = getDirectoryPath(directory);
+            const parentPath = getDirectoryPath(directory);
             if (parentPath === directory) {
                 break;
             }
@@ -145,7 +145,7 @@ namespace ts {
     }
 
     function nameStartsWithDotSlashOrDotDotSlash(name: string) {
-        let i = name.lastIndexOf("./", 1);
+        const i = name.lastIndexOf("./", 1);
         return i === 0 || (i === 1 && name.charCodeAt(0) === CharacterCodes.dot);
     }
 
@@ -159,7 +159,7 @@ namespace ts {
         let searchPath = getDirectoryPath(containingFile);
         let searchName: string;
 
-        let failedLookupLocations: string[] = [];
+        const failedLookupLocations: string[] = [];
 
         let referencedSourceFile: string;
         while (true) {
@@ -171,7 +171,7 @@ namespace ts {
                     return undefined;
                 }
 
-                let candidate = searchName + extension;
+                const candidate = searchName + extension;
                 if (host.fileExists(candidate)) {
                     return candidate;
                 }
@@ -184,7 +184,7 @@ namespace ts {
                 break;
             }
 
-            let parentPath = getDirectoryPath(searchPath);
+            const parentPath = getDirectoryPath(searchPath);
             if (parentPath === searchPath) {
                 break;
             }
@@ -199,15 +199,13 @@ namespace ts {
     /* @internal */
     export const defaultInitCompilerOptions: CompilerOptions = {
         module: ModuleKind.CommonJS,
-        target: ScriptTarget.ES3,
+        target: ScriptTarget.ES5,
         noImplicitAny: false,
-        outDir: "built",
-        rootDir: ".",
         sourceMap: false,
     };
 
     export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost {
-        let existingDirectories: Map<boolean> = {};
+        const existingDirectories: Map<boolean> = {};
 
         function getCanonicalFileName(fileName: string): string {
             // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
@@ -216,12 +214,12 @@ namespace ts {
         }
 
         // returned by CScript sys environment
-        let unsupportedFileEncodingErrorCode = -2147024809;
+        const unsupportedFileEncodingErrorCode = -2147024809;
 
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {
             let text: string;
             try {
-                let start = new Date().getTime();
+                const start = new Date().getTime();
                 text = sys.readFile(fileName, options.charset);
                 ioReadTime += new Date().getTime() - start;
             }
@@ -250,7 +248,7 @@ namespace ts {
 
         function ensureDirectoriesExist(directoryPath: string) {
             if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {
-                let parentDirectory = getDirectoryPath(directoryPath);
+                const parentDirectory = getDirectoryPath(directoryPath);
                 ensureDirectoriesExist(parentDirectory);
                 sys.createDirectory(directoryPath);
             }
@@ -258,7 +256,7 @@ namespace ts {
 
         function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
             try {
-                let start = new Date().getTime();
+                const start = new Date().getTime();
                 ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));
                 sys.writeFile(fileName, data, writeByteOrderMark);
                 ioWriteTime += new Date().getTime() - start;
@@ -286,7 +284,7 @@ namespace ts {
     }
 
     export function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[] {
-        let diagnostics = program.getOptionsDiagnostics().concat(
+        let diagnostics = program.getOptionsDiagnostics(cancellationToken).concat(
                           program.getSyntacticDiagnostics(sourceFile, cancellationToken),
                           program.getGlobalDiagnostics(cancellationToken),
                           program.getSemanticDiagnostics(sourceFile, cancellationToken));
@@ -328,8 +326,8 @@ namespace ts {
         let program: Program;
         let files: SourceFile[] = [];
         let fileProcessingDiagnostics = createDiagnosticCollection();
-        let programDiagnostics = createDiagnosticCollection();
-        let emitBlockingDiagnostics = createDiagnosticCollection();
+        const programDiagnostics = createDiagnosticCollection();
+        const emitBlockingDiagnostics = createDiagnosticCollection();
 
         let commonSourceDirectory: string;
         let diagnosticsProducingTypeChecker: TypeChecker;
@@ -337,28 +335,28 @@ namespace ts {
         let classifiableNames: Map<string>;
 
         let skipDefaultLib = options.noLib;
-        let supportedExtensions = getSupportedExtensions(options);
+        const supportedExtensions = getSupportedExtensions(options);
 
-        let start = new Date().getTime();
+        const start = new Date().getTime();
 
         host = host || createCompilerHost(options);
         // Map storing if there is emit blocking diagnostics for given input
-        let hasEmitBlockingDiagnostics = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : undefined);
+        const hasEmitBlockingDiagnostics = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : undefined);
 
         const currentDirectory = host.getCurrentDirectory();
         const resolveModuleNamesWorker = host.resolveModuleNames
             ? ((moduleNames: string[], containingFile: string) => host.resolveModuleNames(moduleNames, containingFile))
             : ((moduleNames: string[], containingFile: string) => map(moduleNames, moduleName => resolveModuleName(moduleName, containingFile, options, host).resolvedModule));
 
-        let filesByName = createFileMap<SourceFile>();
+        const filesByName = createFileMap<SourceFile>();
         // stores 'filename -> file association' ignoring case
         // used to track cases when two file names differ only in casing 
-        let filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createFileMap<SourceFile>(fileName => fileName.toLowerCase()) : undefined;
+        const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createFileMap<SourceFile>(fileName => fileName.toLowerCase()) : undefined;
 
         if (oldProgram) {
             // check properties that can affect structure of the program or module resolution strategy
             // if any of these properties has changed - structure cannot be reused
-            let oldOptions = oldProgram.getCompilerOptions();
+            const oldOptions = oldProgram.getCompilerOptions();
             if ((oldOptions.module !== options.module) ||
                 (oldOptions.noResolve !== options.noResolve) ||
                 (oldOptions.target !== options.target) ||
@@ -418,7 +416,7 @@ namespace ts {
                 getTypeChecker();
                 classifiableNames = {};
 
-                for (let sourceFile of files) {
+                for (const sourceFile of files) {
                     copyMap(sourceFile.classifiableNames, classifiableNames);
                 }
             }
@@ -434,17 +432,17 @@ namespace ts {
             Debug.assert(!oldProgram.structureIsReused);
 
             // there is an old program, check if we can reuse its structure
-            let oldRootNames = oldProgram.getRootFileNames();
+            const oldRootNames = oldProgram.getRootFileNames();
             if (!arrayIsEqualTo(oldRootNames, rootNames)) {
                 return false;
             }
 
             // check if program source files has changed in the way that can affect structure of the program
-            let newSourceFiles: SourceFile[] = [];
-            let filePaths: Path[] = [];
-            let modifiedSourceFiles: SourceFile[] = [];
+            const newSourceFiles: SourceFile[] = [];
+            const filePaths: Path[] = [];
+            const modifiedSourceFiles: SourceFile[] = [];
 
-            for (let oldSourceFile of oldProgram.getSourceFiles()) {
+            for (const oldSourceFile of oldProgram.getSourceFiles()) {
                 let newSourceFile = host.getSourceFile(oldSourceFile.fileName, options.target);
                 if (!newSourceFile) {
                     return false;
@@ -474,13 +472,13 @@ namespace ts {
                     }
 
                     if (resolveModuleNamesWorker) {
-                        let moduleNames = map(newSourceFile.imports, name => name.text);
-                        let resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));
+                        const moduleNames = map(newSourceFile.imports, name => name.text);
+                        const resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));
                         // ensure that module resolution results are still correct
                         for (let i = 0; i < moduleNames.length; ++i) {
-                            let newResolution = resolutions[i];
-                            let oldResolution = getResolvedModule(oldSourceFile, moduleNames[i]);
-                            let resolutionChanged = oldResolution
+                            const newResolution = resolutions[i];
+                            const oldResolution = getResolvedModule(oldSourceFile, moduleNames[i]);
+                            const resolutionChanged = oldResolution
                                 ? !newResolution ||
                                   oldResolution.resolvedFileName !== newResolution.resolvedFileName ||
                                   !!oldResolution.isExternalLibraryImport !== !!newResolution.isExternalLibraryImport
@@ -512,7 +510,7 @@ namespace ts {
             files = newSourceFiles;
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
 
-            for (let modifiedFile of modifiedSourceFiles) {
+            for (const modifiedFile of modifiedSourceFiles) {
                 fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);
             }
             oldProgram.structureIsReused = true;
@@ -567,11 +565,11 @@ namespace ts {
             // This is because in the -out scenario all files need to be emitted, and therefore all
             // files need to be type checked. And the way to specify that all files need to be type
             // checked is to not pass the file to getEmitResolver.
-            let emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
+            const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
 
-            let start = new Date().getTime();
+            const start = new Date().getTime();
 
-            let emitResult = emitFiles(
+            const emitResult = emitFiles(
                 emitResolver,
                 getEmitHost(writeFileCallback),
                 sourceFile);
@@ -592,7 +590,7 @@ namespace ts {
                 return getDiagnostics(sourceFile, cancellationToken);
             }
 
-            let allDiagnostics: Diagnostic[] = [];
+            const allDiagnostics: Diagnostic[] = [];
             forEach(program.getSourceFiles(), sourceFile => {
                 if (cancellationToken) {
                     cancellationToken.throwIfCancellationRequested();
@@ -651,13 +649,13 @@ namespace ts {
             }
 
             return runWithCancellationToken(() => {
-                let typeChecker = getDiagnosticsProducingTypeChecker();
+                const typeChecker = getDiagnosticsProducingTypeChecker();
 
                 Debug.assert(!!sourceFile.bindDiagnostics);
-                let bindDiagnostics = sourceFile.bindDiagnostics;
-                let checkDiagnostics = typeChecker.getDiagnostics(sourceFile, cancellationToken);
-                let fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);
-                let programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);
+                const bindDiagnostics = sourceFile.bindDiagnostics;
+                const checkDiagnostics = typeChecker.getDiagnostics(sourceFile, cancellationToken);
+                const fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);
+                const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);
 
                 return bindDiagnostics.concat(checkDiagnostics).concat(fileProcessingDiagnosticsInFile).concat(programDiagnosticsInFile);
             });
@@ -665,7 +663,7 @@ namespace ts {
 
         function getJavaScriptSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {
             return runWithCancellationToken(() => {
-                let diagnostics: Diagnostic[] = [];
+                const diagnostics: Diagnostic[] = [];
                 walk(sourceFile);
 
                 return diagnostics;
@@ -714,7 +712,7 @@ namespace ts {
                         case SyntaxKind.FunctionDeclaration:
                         case SyntaxKind.ArrowFunction:
                         case SyntaxKind.FunctionDeclaration:
-                            let functionDeclaration = <FunctionLikeDeclaration>node;
+                            const functionDeclaration = <FunctionLikeDeclaration>node;
                             if (checkModifiers(functionDeclaration.modifiers) ||
                                 checkTypeParameters(functionDeclaration.typeParameters) ||
                                 checkTypeAnnotation(functionDeclaration.type)) {
@@ -722,31 +720,31 @@ namespace ts {
                             }
                             break;
                         case SyntaxKind.VariableStatement:
-                            let variableStatement = <VariableStatement>node;
+                            const variableStatement = <VariableStatement>node;
                             if (checkModifiers(variableStatement.modifiers)) {
                                 return true;
                             }
                             break;
                         case SyntaxKind.VariableDeclaration:
-                            let variableDeclaration = <VariableDeclaration>node;
+                            const variableDeclaration = <VariableDeclaration>node;
                             if (checkTypeAnnotation(variableDeclaration.type)) {
                                 return true;
                             }
                             break;
                         case SyntaxKind.CallExpression:
                         case SyntaxKind.NewExpression:
-                            let expression = <CallExpression>node;
+                            const expression = <CallExpression>node;
                             if (expression.typeArguments && expression.typeArguments.length > 0) {
-                                let start = expression.typeArguments.pos;
+                                const start = expression.typeArguments.pos;
                                 diagnostics.push(createFileDiagnostic(sourceFile, start, expression.typeArguments.end - start,
                                     Diagnostics.type_arguments_can_only_be_used_in_a_ts_file));
                                 return true;
                             }
                             break;
                         case SyntaxKind.Parameter:
-                            let parameter = <ParameterDeclaration>node;
+                            const parameter = <ParameterDeclaration>node;
                             if (parameter.modifiers) {
-                                let start = parameter.modifiers.pos;
+                                const start = parameter.modifiers.pos;
                                 diagnostics.push(createFileDiagnostic(sourceFile, start, parameter.modifiers.end - start,
                                     Diagnostics.parameter_modifiers_can_only_be_used_in_a_ts_file));
                                 return true;
@@ -780,7 +778,7 @@ namespace ts {
 
                 function checkTypeParameters(typeParameters: NodeArray<TypeParameterDeclaration>): boolean {
                     if (typeParameters) {
-                        let start = typeParameters.pos;
+                        const start = typeParameters.pos;
                         diagnostics.push(createFileDiagnostic(sourceFile, start, typeParameters.end - start, Diagnostics.type_parameter_declarations_can_only_be_used_in_a_ts_file));
                         return true;
                     }
@@ -798,7 +796,7 @@ namespace ts {
 
                 function checkModifiers(modifiers: ModifiersArray): boolean {
                     if (modifiers) {
-                        for (let modifier of modifiers) {
+                        for (const modifier of modifiers) {
                             switch (modifier.kind) {
                                 case SyntaxKind.PublicKeyword:
                                 case SyntaxKind.PrivateKeyword:
@@ -825,16 +823,16 @@ namespace ts {
         function getDeclarationDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {
             return runWithCancellationToken(() => {
                 if (!isDeclarationFile(sourceFile)) {
-                    let resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken);
+                    const resolver = getDiagnosticsProducingTypeChecker().getEmitResolver(sourceFile, cancellationToken);
                     // Don't actually write any files since we're just getting diagnostics.
-                    let writeFile: WriteFileCallback = () => { };
+                    const writeFile: WriteFileCallback = () => { };
                     return ts.getDeclarationDiagnostics(getEmitHost(writeFile), resolver, sourceFile);
                 }
             });
         }
 
         function getOptionsDiagnostics(): Diagnostic[] {
-            let allDiagnostics: Diagnostic[] = [];
+            const allDiagnostics: Diagnostic[] = [];
             addRange(allDiagnostics, fileProcessingDiagnostics.getGlobalDiagnostics());
             addRange(allDiagnostics, programDiagnostics.getGlobalDiagnostics());
             addRange(allDiagnostics, emitBlockingDiagnostics.getGlobalDiagnostics());
@@ -842,7 +840,7 @@ namespace ts {
         }
 
         function getGlobalDiagnostics(): Diagnostic[] {
-            let allDiagnostics: Diagnostic[] = [];
+            const allDiagnostics: Diagnostic[] = [];
             addRange(allDiagnostics, getDiagnosticsProducingTypeChecker().getGlobalDiagnostics());
             return sortAndDeduplicateDiagnostics(allDiagnostics);
         }
@@ -869,7 +867,7 @@ namespace ts {
             }
 
             let imports: LiteralExpression[];
-            for (let node of file.statements) {
+            for (const node of file.statements) {
                 collect(node, /* allowRelativeModuleNames */ true);
             }
 
@@ -929,7 +927,7 @@ namespace ts {
                 }
             }
             else {
-                let nonTsFile: SourceFile = options.allowNonTsExtensions && findSourceFile(fileName, toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd);
+                const nonTsFile: SourceFile = options.allowNonTsExtensions && findSourceFile(fileName, toPath(fileName, currentDirectory, getCanonicalFileName), isDefaultLib, refFile, refPos, refEnd);
                 if (!nonTsFile) {
                     if (options.allowNonTsExtensions) {
                         diagnostic = Diagnostics.File_0_not_found;
@@ -978,7 +976,7 @@ namespace ts {
             }
 
             // We haven't looked for this file, do so now and cache result
-            let file = host.getSourceFile(fileName, options.target, hostErrorMessage => {
+            const file = host.getSourceFile(fileName, options.target, hostErrorMessage => {
                 if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) {
                     fileProcessingDiagnostics.add(createFileDiagnostic(refFile, refPos, refEnd - refPos,
                         Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage));
@@ -1005,7 +1003,7 @@ namespace ts {
 
                 skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib;
 
-                let basePath = getDirectoryPath(fileName);
+                const basePath = getDirectoryPath(fileName);
                 if (!options.noResolve) {
                     processReferencedFiles(file, basePath);
                 }
@@ -1027,7 +1025,7 @@ namespace ts {
 
         function processReferencedFiles(file: SourceFile, basePath: string) {
             forEach(file.referencedFiles, ref => {
-                let referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName);
+                const referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName);
                 processSourceFile(referencedFileName, /* isDefaultLib */ false, file, ref.pos, ref.end);
             });
         }
@@ -1040,21 +1038,21 @@ namespace ts {
             collectExternalModuleReferences(file);
             if (file.imports.length) {
                 file.resolvedModules = {};
-                let moduleNames = map(file.imports, name => name.text);
-                let resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(file.fileName, currentDirectory));
+                const moduleNames = map(file.imports, name => name.text);
+                const resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(file.fileName, currentDirectory));
                 for (let i = 0; i < file.imports.length; ++i) {
-                    let resolution = resolutions[i];
+                    const resolution = resolutions[i];
                     setResolvedModule(file, moduleNames[i], resolution);
                     if (resolution && !options.noResolve) {
                         const importedFile = findSourceFile(resolution.resolvedFileName, toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), /* isDefaultLib */ false, file, skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
 
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!isExternalModule(importedFile)) {
-                                let start = getTokenPosOfNode(file.imports[i], file);
+                                const start = getTokenPosOfNode(file.imports[i], file);
                                 fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition, importedFile.fileName));
                             }
                             else if (importedFile.referencedFiles.length) {
-                                let firstRef = importedFile.referencedFiles[0];
+                                const firstRef = importedFile.referencedFiles[0];
                                 fileProcessingDiagnostics.add(createFileDiagnostic(importedFile, firstRef.pos, firstRef.end - firstRef.pos, Diagnostics.Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition));
                             }
                         }
@@ -1076,7 +1074,7 @@ namespace ts {
                     return;
                 }
 
-                let sourcePathComponents = getNormalizedPathComponents(sourceFile.fileName, currentDirectory);
+                const sourcePathComponents = getNormalizedPathComponents(sourceFile.fileName, currentDirectory);
                 sourcePathComponents.pop(); // The base file name is not part of the common directory path
 
                 if (!commonPathComponents) {
@@ -1110,11 +1108,11 @@ namespace ts {
         function checkSourceFilesBelongToPath(sourceFiles: SourceFile[], rootDirectory: string): boolean {
             let allFilesBelongToPath = true;
             if (sourceFiles) {
-                let absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
+                const absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
 
                 for (var sourceFile of sourceFiles) {
                     if (!isDeclarationFile(sourceFile)) {
-                        let absoluteSourceFilePath = host.getCanonicalFileName(getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
+                        const absoluteSourceFilePath = host.getCanonicalFileName(getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
                         if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
                             programDiagnostics.add(createCompilerDiagnostic(Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, sourceFile.fileName, options.rootDir));
                             allFilesBelongToPath = false;
@@ -1179,24 +1177,24 @@ namespace ts {
                 return;
             }
 
-            let languageVersion = options.target || ScriptTarget.ES3;
-            let outFile = options.outFile || options.out;
+            const languageVersion = options.target || ScriptTarget.ES3;
+            const outFile = options.outFile || options.out;
 
-            let firstExternalModuleSourceFile = forEach(files, f => isExternalModule(f) ? f : undefined);
+            const firstExternalModuleSourceFile = forEach(files, f => isExternalModule(f) ? f : undefined);
             if (options.isolatedModules) {
                 if (!options.module && languageVersion < ScriptTarget.ES6) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher));
                 }
 
-                let firstNonExternalModuleSourceFile = forEach(files, f => !isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
+                const firstNonExternalModuleSourceFile = forEach(files, f => !isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
                 if (firstNonExternalModuleSourceFile) {
-                    let span = getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile);
+                    const span = getErrorSpanForNode(firstNonExternalModuleSourceFile, firstNonExternalModuleSourceFile);
                     programDiagnostics.add(createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided));
                 }
             }
             else if (firstExternalModuleSourceFile && languageVersion < ScriptTarget.ES6 && !options.module) {
                 // We cannot use createDiagnosticFromNode because nodes do not have parents yet
-                let span = getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
+                const span = getErrorSpanForNode(firstExternalModuleSourceFile, firstExternalModuleSourceFile.externalModuleIndicator);
                 programDiagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_modules_unless_the_module_flag_is_provided));
             }
 
@@ -1257,8 +1255,8 @@ namespace ts {
 
             // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files
             if (!options.noEmit) {
-                let emitHost = getEmitHost();
-                let emitFilesSeen = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : undefined);
+                const emitHost = getEmitHost();
+                const emitFilesSeen = createFileMap<boolean>(!host.useCaseSensitiveFileNames() ? key => key.toLocaleLowerCase() : undefined);
                 forEachExpectedEmitFile(emitHost, (emitFileNames, sourceFiles, isBundledEmit) => {
                     verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
                     verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen);
@@ -1268,7 +1266,7 @@ namespace ts {
             // Verify that all the emit files are unique and dont overwrite input files
             function verifyEmitFilePath(emitFileName: string, emitFilesSeen: FileMap<boolean>) {
                 if (emitFileName) {
-                    let emitFilePath = toPath(emitFileName, currentDirectory, getCanonicalFileName);
+                    const emitFilePath = toPath(emitFileName, currentDirectory, getCanonicalFileName);
                     // Report error if the output overwrites input file
                     if (forEach(files, file => toPath(file.fileName, currentDirectory, getCanonicalFileName) === emitFilePath)) {
                         createEmitBlockingDiagnostics(emitFileName, Diagnostics.Cannot_write_file_0_because_it_would_overwrite_input_file);
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index a827d755302..4e11e0d6b99 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -49,7 +49,7 @@ namespace ts {
         tryScan<T>(callback: () => T): T;
     }
 
-    let textToToken: Map<SyntaxKind> = {
+    const textToToken: Map<SyntaxKind> = {
         "abstract": SyntaxKind.AbstractKeyword,
         "any": SyntaxKind.AnyKeyword,
         "as": SyntaxKind.AsKeyword,
@@ -191,8 +191,8 @@ namespace ts {
         Codepoint ranges for ES3 Identifiers are extracted from the Unicode 3.0.0 specification at:
         http://www.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.txt
     */
-    let unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
-    let unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
+    const unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
+    const unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
 
     /*
         As per ECMAScript Language Specification 5th Edition, Section 7.6: ISyntaxToken Names and Identifiers
@@ -216,8 +216,8 @@ namespace ts {
         Codepoint ranges for ES5 Identifiers are extracted from the Unicode 6.2 specification at:
         http://www.unicode.org/Public/6.2.0/ucd/UnicodeData.txt
     */
-    let unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
-    let unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
+    const unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
+    const unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, ];
 
     function lookupInUnicodeMap(code: number, map: number[]): boolean {
         // Bail out quickly if it couldn't possibly be in the map.
@@ -262,8 +262,8 @@ namespace ts {
     }
 
     function makeReverseMap(source: Map<number>): string[] {
-        let result: string[] = [];
-        for (let name in source) {
+        const result: string[] = [];
+        for (const name in source) {
             if (source.hasOwnProperty(name)) {
                 result[source[name]] = name;
             }
@@ -271,7 +271,7 @@ namespace ts {
         return result;
     }
 
-    let tokenStrings = makeReverseMap(textToToken);
+    const tokenStrings = makeReverseMap(textToToken);
 
     export function tokenToString(t: SyntaxKind): string {
         return tokenStrings[t];
@@ -284,11 +284,11 @@ namespace ts {
 
     /* @internal */
     export function computeLineStarts(text: string): number[] {
-        let result: number[] = new Array();
+        const result: number[] = new Array();
         let pos = 0;
         let lineStart = 0;
         while (pos < text.length) {
-           let ch = text.charCodeAt(pos++);
+           const ch = text.charCodeAt(pos++);
            switch (ch) {
                 case CharacterCodes.carriageReturn:
                     if (text.charCodeAt(pos) === CharacterCodes.lineFeed) {
@@ -352,7 +352,7 @@ namespace ts {
         return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
     }
 
-    let hasOwnProperty = Object.prototype.hasOwnProperty;
+    const hasOwnProperty = Object.prototype.hasOwnProperty;
 
     export function isWhiteSpace(ch: number): boolean {
         // Note: nextLine is in the Zs space, and should be considered to be a whitespace.
@@ -400,7 +400,7 @@ namespace ts {
 
       export function couldStartTrivia(text: string, pos: number): boolean {
           // Keep in sync with skipTrivia
-          let ch = text.charCodeAt(pos);
+          const ch = text.charCodeAt(pos);
           switch (ch) {
               case CharacterCodes.carriageReturn:
               case CharacterCodes.lineFeed:
@@ -427,7 +427,7 @@ namespace ts {
       export function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number {
           // Keep in sync with couldStartTrivia
           while (true) {
-              let ch = text.charCodeAt(pos);
+              const ch = text.charCodeAt(pos);
               switch (ch) {
                   case CharacterCodes.carriageReturn:
                       if (text.charCodeAt(pos + 1) === CharacterCodes.lineFeed) {
@@ -498,14 +498,14 @@ namespace ts {
 
       // All conflict markers consist of the same character repeated seven times.  If it is
       // a <<<<<<< or >>>>>>> marker then it is also followd by a space.
-    let mergeConflictMarkerLength = "<<<<<<<".length;
+    const mergeConflictMarkerLength = "<<<<<<<".length;
 
     function isConflictMarkerTrivia(text: string, pos: number) {
         Debug.assert(pos >= 0);
 
         // Conflict markers must be at the start of a line.
         if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) {
-            let ch = text.charCodeAt(pos);
+            const ch = text.charCodeAt(pos);
 
             if ((pos + mergeConflictMarkerLength) < text.length) {
                 for (let i = 0, n = mergeConflictMarkerLength; i < n; i++) {
@@ -527,8 +527,8 @@ namespace ts {
             error(Diagnostics.Merge_conflict_marker_encountered, mergeConflictMarkerLength);
         }
 
-        let ch = text.charCodeAt(pos);
-        let len = text.length;
+        const ch = text.charCodeAt(pos);
+        const len = text.length;
 
         if (ch === CharacterCodes.lessThan || ch === CharacterCodes.greaterThan) {
             while (pos < len && !isLineBreak(text.charCodeAt(pos))) {
@@ -540,7 +540,7 @@ namespace ts {
             // Consume everything from the start of the mid-conlict marker to the start of the next
             // end-conflict marker.
             while (pos < len) {
-                let ch = text.charCodeAt(pos);
+                const ch = text.charCodeAt(pos);
                 if (ch === CharacterCodes.greaterThan && isConflictMarkerTrivia(text, pos)) {
                     break;
                 }
@@ -561,7 +561,7 @@ namespace ts {
     }
 
     function scanShebangTrivia(text: string, pos: number) {
-        let shebang = shebangTriviaRegex.exec(text)[0];
+        const shebang = shebangTriviaRegex.exec(text)[0];
         pos = pos + shebang.length;
         return pos;
     }
@@ -581,7 +581,7 @@ namespace ts {
         let result: CommentRange[];
         let collecting = trailing || pos === 0;
         while (true) {
-            let ch = text.charCodeAt(pos);
+            const ch = text.charCodeAt(pos);
             switch (ch) {
                 case CharacterCodes.carriageReturn:
                     if (text.charCodeAt(pos + 1) === CharacterCodes.lineFeed) {
@@ -607,8 +607,8 @@ namespace ts {
                     let nextChar = text.charCodeAt(pos + 1);
                     let hasTrailingNewLine = false;
                     if (nextChar === CharacterCodes.slash || nextChar === CharacterCodes.asterisk) {
-                        let kind = nextChar === CharacterCodes.slash ? SyntaxKind.SingleLineCommentTrivia : SyntaxKind.MultiLineCommentTrivia;
-                        let startPos = pos;
+                        const kind = nextChar === CharacterCodes.slash ? SyntaxKind.SingleLineCommentTrivia : SyntaxKind.MultiLineCommentTrivia;
+                        const startPos = pos;
                         pos += 2;
                         if (nextChar === CharacterCodes.slash) {
                             while (pos < text.length) {
@@ -742,7 +742,7 @@ namespace ts {
         }
 
         function scanNumber(): number {
-            let start = pos;
+            const start = pos;
             while (isDigit(text.charCodeAt(pos))) pos++;
             if (text.charCodeAt(pos) === CharacterCodes.dot) {
                 pos++;
@@ -765,7 +765,7 @@ namespace ts {
         }
 
         function scanOctalDigits(): number {
-            let start = pos;
+            const start = pos;
             while (isOctalDigit(text.charCodeAt(pos))) {
                 pos++;
             }
@@ -792,7 +792,7 @@ namespace ts {
             let digits = 0;
             let value = 0;
             while (digits < minCount || scanAsManyAsPossible) {
-                let ch = text.charCodeAt(pos);
+                const ch = text.charCodeAt(pos);
                 if (ch >= CharacterCodes._0 && ch <= CharacterCodes._9) {
                     value = value * 16 + ch - CharacterCodes._0;
                 }
@@ -815,7 +815,7 @@ namespace ts {
         }
 
         function scanString(): string {
-            let quote = text.charCodeAt(pos++);
+            const quote = text.charCodeAt(pos++);
             let result = "";
             let start = pos;
             while (true) {
@@ -825,7 +825,7 @@ namespace ts {
                     error(Diagnostics.Unterminated_string_literal);
                     break;
                 }
-                let ch = text.charCodeAt(pos);
+                const ch = text.charCodeAt(pos);
                 if (ch === quote) {
                     result += text.substring(start, pos);
                     pos++;
@@ -853,7 +853,7 @@ namespace ts {
          * a literal component of a TemplateExpression.
          */
         function scanTemplateAndSetTokenValue(): SyntaxKind {
-            let startedWithBacktick = text.charCodeAt(pos) === CharacterCodes.backtick;
+            const startedWithBacktick = text.charCodeAt(pos) === CharacterCodes.backtick;
 
             pos++;
             let start = pos;
@@ -869,7 +869,7 @@ namespace ts {
                     break;
                 }
 
-                let currChar = text.charCodeAt(pos);
+                const currChar = text.charCodeAt(pos);
 
                 // '`'
                 if (currChar === CharacterCodes.backtick) {
@@ -925,7 +925,7 @@ namespace ts {
                 error(Diagnostics.Unexpected_end_of_text);
                 return "";
             }
-            let ch = text.charCodeAt(pos++);
+            const ch = text.charCodeAt(pos++);
             switch (ch) {
                 case CharacterCodes._0:
                     return "\0";
@@ -977,7 +977,7 @@ namespace ts {
         }
 
         function scanHexadecimalEscape(numDigits: number): string {
-            let escapedValue = scanExactNumberOfHexDigits(numDigits);
+            const escapedValue = scanExactNumberOfHexDigits(numDigits);
 
             if (escapedValue >= 0) {
                 return String.fromCharCode(escapedValue);
@@ -989,7 +989,7 @@ namespace ts {
         }
 
         function scanExtendedUnicodeEscape(): string {
-            let escapedValue = scanMinimumNumberOfHexDigits(1);
+            const escapedValue = scanMinimumNumberOfHexDigits(1);
             let isInvalidExtendedEscape = false;
 
             // Validate the value of the digit
@@ -1030,8 +1030,8 @@ namespace ts {
                 return String.fromCharCode(codePoint);
             }
 
-            let codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 0xD800;
-            let codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00;
+            const codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 0xD800;
+            const codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00;
 
             return String.fromCharCode(codeUnit1, codeUnit2);
         }
@@ -1040,9 +1040,9 @@ namespace ts {
         // and return code point value if valid Unicode escape is found. Otherwise return -1.
         function peekUnicodeEscape(): number {
             if (pos + 5 < end && text.charCodeAt(pos + 1) === CharacterCodes.u) {
-                let start = pos;
+                const start = pos;
                 pos += 2;
-                let value = scanExactNumberOfHexDigits(4);
+                const value = scanExactNumberOfHexDigits(4);
                 pos = start;
                 return value;
             }
@@ -1078,9 +1078,9 @@ namespace ts {
 
         function getIdentifierToken(): SyntaxKind {
             // Reserved words are between 2 and 11 characters long and start with a lowercase letter
-            let len = tokenValue.length;
+            const len = tokenValue.length;
             if (len >= 2 && len <= 11) {
-                let ch = tokenValue.charCodeAt(0);
+                const ch = tokenValue.charCodeAt(0);
                 if (ch >= CharacterCodes.a && ch <= CharacterCodes.z && hasOwnProperty.call(textToToken, tokenValue)) {
                     return token = textToToken[tokenValue];
                 }
@@ -1096,8 +1096,8 @@ namespace ts {
             // Similarly valid octalIntegerLiteral must have at least one octal digit following o or O.
             let numberOfDigits = 0;
             while (true) {
-                let ch = text.charCodeAt(pos);
-                let valueOfCh = ch - CharacterCodes._0;
+                const ch = text.charCodeAt(pos);
+                const valueOfCh = ch - CharacterCodes._0;
                 if (!isDigit(ch) || valueOfCh >= base) {
                     break;
                 }
@@ -1262,7 +1262,7 @@ namespace ts {
 
                             let commentClosed = false;
                             while (pos < end) {
-                                let ch = text.charCodeAt(pos);
+                                const ch = text.charCodeAt(pos);
 
                                 if (ch === CharacterCodes.asterisk && text.charCodeAt(pos + 1) === CharacterCodes.slash) {
                                     pos += 2;
@@ -1504,7 +1504,7 @@ namespace ts {
                         break;
                     }
 
-                    let ch = text.charCodeAt(p);
+                    const ch = text.charCodeAt(p);
                     if (isLineBreak(ch)) {
                         tokenIsUnterminated = true;
                         error(Diagnostics.Unterminated_regular_expression_literal);
@@ -1594,9 +1594,9 @@ namespace ts {
         // they allow dashes
         function scanJsxIdentifier(): SyntaxKind {
             if (tokenIsIdentifierOrKeyword(token)) {
-                let firstCharPosition = pos;
+                const firstCharPosition = pos;
                 while (pos < end) {
-                    let ch = text.charCodeAt(pos);
+                    const ch = text.charCodeAt(pos);
                     if (ch === CharacterCodes.minus || ((firstCharPosition === pos) ? isIdentifierStart(ch, languageVersion) : isIdentifierPart(ch, languageVersion))) {
                         pos++;
                     }
@@ -1610,13 +1610,13 @@ namespace ts {
         }
 
         function speculationHelper<T>(callback: () => T, isLookahead: boolean): T {
-            let savePos = pos;
-            let saveStartPos = startPos;
-            let saveTokenPos = tokenPos;
-            let saveToken = token;
-            let saveTokenValue = tokenValue;
-            let savePrecedingLineBreak = precedingLineBreak;
-            let result = callback();
+            const savePos = pos;
+            const saveStartPos = startPos;
+            const saveTokenPos = tokenPos;
+            const saveToken = token;
+            const saveTokenValue = tokenValue;
+            const savePrecedingLineBreak = precedingLineBreak;
+            const result = callback();
 
             // If our callback returned something 'falsy' or we're just looking ahead,
             // then unconditionally restore us to where we were.
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 3eeb126c065..3a90ca42fa1 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -51,15 +51,15 @@ namespace ts {
 
         function getWScriptSystem(): System {
 
-            let fso = new ActiveXObject("Scripting.FileSystemObject");
+            const fso = new ActiveXObject("Scripting.FileSystemObject");
 
-            let fileStream = new ActiveXObject("ADODB.Stream");
+            const fileStream = new ActiveXObject("ADODB.Stream");
             fileStream.Type = 2 /*text*/;
 
-            let binaryStream = new ActiveXObject("ADODB.Stream");
+            const binaryStream = new ActiveXObject("ADODB.Stream");
             binaryStream.Type = 1 /*binary*/;
 
-            let args: string[] = [];
+            const args: string[] = [];
             for (let i = 0; i < WScript.Arguments.length; i++) {
                 args[i] = WScript.Arguments.Item(i);
             }
@@ -78,7 +78,7 @@ namespace ts {
                         // Load file and read the first two bytes into a string with no interpretation
                         fileStream.Charset = "x-ansi";
                         fileStream.LoadFromFile(fileName);
-                        let bom = fileStream.ReadText(2) || "";
+                        const bom = fileStream.ReadText(2) || "";
                         // Position must be at 0 before encoding can be changed
                         fileStream.Position = 0;
                         // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8
@@ -124,7 +124,7 @@ namespace ts {
             }
 
             function getNames(collection: any): string[] {
-                let result: string[] = [];
+                const result: string[] = [];
                 for (let e = new Enumerator(collection); !e.atEnd(); e.moveNext()) {
                     result.push(e.item().Name);
                 }
@@ -132,22 +132,22 @@ namespace ts {
             }
 
             function readDirectory(path: string, extension?: string, exclude?: string[]): string[] {
-                let result: string[] = [];
+                const result: string[] = [];
                 exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
                 visitDirectory(path);
                 return result;
                 function visitDirectory(path: string) {
-                    let folder = fso.GetFolder(path || ".");
-                    let files = getNames(folder.files);
-                    for (let current of files) {
-                        let name = combinePaths(path, current);
+                    const folder = fso.GetFolder(path || ".");
+                    const files = getNames(folder.files);
+                    for (const current of files) {
+                        const name = combinePaths(path, current);
                         if ((!extension || fileExtensionIs(name, extension)) && !contains(exclude, getCanonicalPath(name))) {
                             result.push(name);
                         }
                     }
-                    let subfolders = getNames(folder.subfolders);
-                    for (let current of subfolders) {
-                        let name = combinePaths(path, current);
+                    const subfolders = getNames(folder.subfolders);
+                    for (const current of subfolders) {
+                        const name = combinePaths(path, current);
                         if (!contains(exclude, getCanonicalPath(name))) {
                             visitDirectory(name);
                         }
@@ -198,6 +198,7 @@ namespace ts {
             const _fs = require("fs");
             const _path = require("path");
             const _os = require("os");
+            const _tty = require("tty");
 
             // average async stat takes about 30 microseconds
             // set chunk size to do 30 files in < 1 millisecond
@@ -211,7 +212,7 @@ namespace ts {
                 }
 
                 function poll(checkedIndex: number) {
-                    let watchedFile = watchedFiles[checkedIndex];
+                    const watchedFile = watchedFiles[checkedIndex];
                     if (!watchedFile) {
                         return;
                     }
@@ -251,7 +252,7 @@ namespace ts {
                 }
 
                 function addFile(fileName: string, callback: (fileName: string, removed?: boolean) => void): WatchedFile {
-                    let file: WatchedFile = {
+                    const file: WatchedFile = {
                         fileName,
                         callback,
                         mtime: getModifiedTime(fileName)
@@ -290,7 +291,7 @@ namespace ts {
             // changes for large reference sets? If so, do we want
             // to increase the chunk size or decrease the interval
             // time dynamically to match the large reference set?
-            let watchedFileSet = createWatchedFileSet();
+            const watchedFileSet = createWatchedFileSet();
 
             function isNode4OrLater(): Boolean {
                 return parseInt(process.version.charAt(1)) >= 4;
@@ -304,14 +305,14 @@ namespace ts {
                 if (!_fs.existsSync(fileName)) {
                     return undefined;
                 }
-                let buffer = _fs.readFileSync(fileName);
+                const buffer = _fs.readFileSync(fileName);
                 let len = buffer.length;
                 if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) {
                     // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js,
                     // flip all byte pairs and treat as little endian.
                     len &= ~1;
                     for (let i = 0; i < len; i += 2) {
-                        let temp = buffer[i];
+                        const temp = buffer[i];
                         buffer[i] = buffer[i + 1];
                         buffer[i + 1] = temp;
                     }
@@ -335,7 +336,17 @@ namespace ts {
                     data = "\uFEFF" + data;
                 }
 
-                _fs.writeFileSync(fileName, data, "utf8");
+                let fd: number;
+
+                try {
+                    fd = _fs.openSync(fileName, "w");
+                    _fs.writeSync(fd, data, undefined, "utf8");
+                }
+                finally {
+                    if (fd !== undefined) {
+                        _fs.closeSync(fd);
+                    }
+                }
             }
 
             function getCanonicalPath(path: string): string {
@@ -343,17 +354,17 @@ namespace ts {
             }
 
             function readDirectory(path: string, extension?: string, exclude?: string[]): string[] {
-                let result: string[] = [];
+                const result: string[] = [];
                 exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
                 visitDirectory(path);
                 return result;
                 function visitDirectory(path: string) {
-                    let files = _fs.readdirSync(path || ".").sort();
-                    let directories: string[] = [];
-                    for (let current of files) {
-                        let name = combinePaths(path, current);
+                    const files = _fs.readdirSync(path || ".").sort();
+                    const directories: string[] = [];
+                    for (const current of files) {
+                        const name = combinePaths(path, current);
                         if (!contains(exclude, getCanonicalPath(name))) {
-                            let stat = _fs.statSync(name);
+                            const stat = _fs.statSync(name);
                             if (stat.isFile()) {
                                 if (!extension || fileExtensionIs(name, extension)) {
                                     result.push(name);
@@ -364,7 +375,7 @@ namespace ts {
                             }
                         }
                     }
-                    for (let current of directories) {
+                    for (const current of directories) {
                         visitDirectory(current);
                     }
                 }
@@ -375,15 +386,7 @@ namespace ts {
                 newLine: _os.EOL,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
                 write(s: string): void {
-                    const buffer = new Buffer(s, "utf8");
-                    let offset = 0;
-                    let toWrite: number = buffer.length;
-                    let written = 0;
-                    // 1 is a standard descriptor for stdout
-                    while ((written = _fs.writeSync(1, buffer, offset, toWrite)) < toWrite) {
-                        offset += written;
-                        toWrite -= written;
-                    }
+                    process.stdout.write(s);
                 },
                 readFile,
                 writeFile,
@@ -397,7 +400,7 @@ namespace ts {
                         return _fs.watch(fileName, (eventName: string, relativeFileName: string) => callback(fileName));
                     }
 
-                    let watchedFile = watchedFileSet.addFile(fileName, callback);
+                    const watchedFile = watchedFileSet.addFile(fileName, callback);
                     return {
                         close: () => watchedFileSet.removeFile(watchedFile)
                     };
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index 9489e995766..a89f4c0b5fd 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -6,20 +6,28 @@ namespace ts {
         fileWatcher?: FileWatcher;
     }
 
+    let reportDiagnostic = reportDiagnosticSimply;
+
+    function reportDiagnostics(diagnostics: Diagnostic[], host: CompilerHost): void {
+        for (const diagnostic of diagnostics) {
+            reportDiagnostic(diagnostic, host);
+        }
+    }
+
     /**
      * Checks to see if the locale is in the appropriate format,
      * and if it is, attempts to set the appropriate language.
      */
     function validateLocaleAndSetLanguage(locale: string, errors: Diagnostic[]): boolean {
-        let matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase());
+        const matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase());
 
         if (!matchResult) {
             errors.push(createCompilerDiagnostic(Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp"));
             return false;
         }
 
-        let language = matchResult[1];
-        let territory = matchResult[3];
+        const language = matchResult[1];
+        const territory = matchResult[3];
 
         // First try the entire locale, then fall back to just language if that's all we have.
         if (!trySetLanguageAndTerritory(language, territory, errors) &&
@@ -33,8 +41,8 @@ namespace ts {
     }
 
     function trySetLanguageAndTerritory(language: string, territory: string, errors: Diagnostic[]): boolean {
-        let compilerFilePath = normalizePath(sys.getExecutingFilePath());
-        let containingDirectoryPath = getDirectoryPath(compilerFilePath);
+        const compilerFilePath = normalizePath(sys.getExecutingFilePath());
+        const containingDirectoryPath = getDirectoryPath(compilerFilePath);
 
         let filePath = combinePaths(containingDirectoryPath, language);
 
@@ -77,39 +85,122 @@ namespace ts {
     }
 
     function getDiagnosticText(message: DiagnosticMessage, ...args: any[]): string {
-        let diagnostic = createCompilerDiagnostic.apply(undefined, arguments);
+        const diagnostic = createCompilerDiagnostic.apply(undefined, arguments);
         return <string>diagnostic.messageText;
     }
 
-    function reportDiagnostic(diagnostic: Diagnostic, host: CompilerHost) {
+    function getRelativeFileName(fileName: string, host: CompilerHost): string {
+        return host ? convertToRelativePath(fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName)) : fileName;
+    }
+
+    function reportDiagnosticSimply(diagnostic: Diagnostic, host: CompilerHost): void {
         let output = "";
 
         if (diagnostic.file) {
-            let loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-            const relativeFileName = host
-                ? convertToRelativePath(diagnostic.file.fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName))
-                : diagnostic.file.fileName;
-
-            output += `${ relativeFileName }(${ loc.line + 1 },${ loc.character + 1 }): `;
+            const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            const relativeFileName = getRelativeFileName(diagnostic.file.fileName, host);
+            output += `${ relativeFileName }(${ line + 1 },${ character + 1 }): `;
         }
 
-        let category = DiagnosticCategory[diagnostic.category].toLowerCase();
+        const category = DiagnosticCategory[diagnostic.category].toLowerCase();
         output += `${ category } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
 
         sys.write(output);
     }
 
-    function reportDiagnostics(diagnostics: Diagnostic[], host: CompilerHost) {
-        for (let i = 0; i < diagnostics.length; i++) {
-            reportDiagnostic(diagnostics[i], host);
+
+    const redForegroundEscapeSequence = "\u001b[91m";
+    const yellowForegroundEscapeSequence = "\u001b[93m";
+    const blueForegroundEscapeSequence = "\u001b[93m";
+    const gutterStyleSequence = "\u001b[100;30m";
+    const gutterSeparator = " ";
+    const resetEscapeSequence = "\u001b[0m";
+    const elipsis = "...";
+    const categoryFormatMap: Map<string> = {
+        [DiagnosticCategory.Warning]: yellowForegroundEscapeSequence,
+        [DiagnosticCategory.Error]: redForegroundEscapeSequence,
+        [DiagnosticCategory.Message]: blueForegroundEscapeSequence,
+    };
+
+    function formatAndReset(text: string, formatStyle: string) {
+        return formatStyle + text + resetEscapeSequence;
+    }
+
+    function reportDiagnosticWithColorAndContext(diagnostic: Diagnostic, host: CompilerHost): void {
+        let output = "";
+
+        if (diagnostic.file) {
+            const { start, length, file } = diagnostic;
+            const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start);
+            const { line: lastLine, character: lastLineChar } = getLineAndCharacterOfPosition(file, start + length);
+            const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;
+            const relativeFileName = getRelativeFileName(file.fileName, host);
+
+            const hasMoreThanFiveLines = (lastLine - firstLine) >= 4;
+            let gutterWidth = (lastLine + 1 + "").length;
+            if (hasMoreThanFiveLines) {
+                gutterWidth = Math.max(elipsis.length, gutterWidth);
+            }
+
+            output += sys.newLine;
+            for (let i = firstLine; i <= lastLine; i++) {
+                // If the error spans over 5 lines, we'll only show the first 2 and last 2 lines,
+                // so we'll skip ahead to the second-to-last line.
+                if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
+                    output += formatAndReset(padLeft(elipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + sys.newLine;
+                    i = lastLine - 1;
+                }
+
+                const lineStart = getPositionOfLineAndCharacter(file, i, 0);
+                const lineEnd = i < lastLineInFile ? getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;
+                let lineContent = file.text.slice(lineStart, lineEnd);
+                lineContent = lineContent.replace(/\s+$/g, "");  // trim from end
+                lineContent = lineContent.replace("\t", " ");    // convert tabs to single spaces
+
+                // Output the gutter and the actual contents of the line.
+                output += formatAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;
+                output += lineContent + sys.newLine;
+
+                // Output the gutter and the error span for the line using tildes.
+                output += formatAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;
+                output += redForegroundEscapeSequence;
+                if (i === firstLine) {
+                    // If we're on the last line, then limit it to the last character of the last line.
+                    // Otherwise, we'll just squiggle the rest of the line, giving 'slice' no end position.
+                    const lastCharForLine = i === lastLine ? lastLineChar : undefined;
+
+                    output += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
+                    output += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");
+                }
+                else if (i === lastLine) {
+                    output += lineContent.slice(0, lastLineChar).replace(/./g, "~");
+                }
+                else {
+                    // Squiggle the entire line.
+                    output += lineContent.replace(/./g, "~");
+                }
+                output += resetEscapeSequence;
+
+                output += sys.newLine;
+            }
+
+            output += sys.newLine;
+            output += `${ relativeFileName }(${ firstLine + 1 },${ firstLineChar + 1 }): `;
         }
+
+        const categoryColor = categoryFormatMap[diagnostic.category];
+        const category = DiagnosticCategory[diagnostic.category].toLowerCase();
+        output += `${ formatAndReset(category, categoryColor) } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }`;
+        output += sys.newLine + sys.newLine;
+
+        sys.write(output);
     }
 
     function reportWatchDiagnostic(diagnostic: Diagnostic) {
         let output = new Date().toLocaleTimeString() + " - ";
 
         if (diagnostic.file) {
-            let loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            const loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
             output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `;
         }
 
@@ -150,7 +241,7 @@ namespace ts {
     }
 
     export function executeCommandLine(args: string[]): void {
-        let commandLine = parseCommandLine(args);
+        const commandLine = parseCommandLine(args);
         let configFileName: string;                                 // Configuration file name (if any)
         let cachedConfigFileText: string;                           // Cached configuration file text, used for reparsing (if any)
         let configFileWatcher: FileWatcher;                         // Configuration file watcher
@@ -211,7 +302,7 @@ namespace ts {
             }
         }
         else if (commandLine.fileNames.length === 0 && isJSONSupported()) {
-            let searchPath = normalizePath(sys.getCurrentDirectory());
+            const searchPath = normalizePath(sys.getCurrentDirectory());
             configFileName = findConfigFile(searchPath, sys.fileExists);
         }
 
@@ -231,7 +322,7 @@ namespace ts {
                 configFileWatcher = sys.watchFile(configFileName, configFileChanged);
             }
             if (sys.watchDirectory && configFileName) {
-                let directory = ts.getDirectoryPath(configFileName);
+                const directory = ts.getDirectoryPath(configFileName);
                 directoryWatcher = sys.watchDirectory(
                     // When the configFileName is just "tsconfig.json", the watched directory should be 
                     // the current direcotry; if there is a given "project" parameter, then the configFileName
@@ -249,16 +340,16 @@ namespace ts {
                     cachedConfigFileText = sys.readFile(configFileName);
                 }
                 catch (e) {
-                    let error = createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, configFileName, e.message);
+                    const error = createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, configFileName, e.message);
                     reportWatchDiagnostic(error);
                     sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
                     return;
                 }
             }
 
-            let result = parseConfigFileTextToJson(configFileName, cachedConfigFileText);
-            let configObject = result.config;
-            let configParseResult = parseJsonConfigFileContent(configObject, sys, getDirectoryPath(configFileName), commandLine.options);
+            const result = parseConfigFileTextToJson(configFileName, cachedConfigFileText);
+            const configObject = result.config;
+            const configParseResult = parseJsonConfigFileContent(configObject, sys, getDirectoryPath(configFileName), commandLine.options);
             if (configParseResult.errors.length > 0) {
                 reportDiagnostics(configParseResult.errors, /* compilerHost */ undefined);
                 sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
@@ -272,7 +363,7 @@ namespace ts {
 
             if (!cachedProgram) {
                 if (configFileName) {
-                    let configParseResult = parseConfigFile();
+                    const configParseResult = parseConfigFile();
                     rootFileNames = configParseResult.fileNames;
                     compilerOptions = configParseResult.options;
                 }
@@ -288,10 +379,14 @@ namespace ts {
                 compilerHost.fileExists = cachedFileExists;
             }
 
+            if (compilerOptions.pretty) {
+                reportDiagnostic = reportDiagnosticWithColorAndContext;
+            }
+
             // reset the cache of existing files
             cachedExistingFiles = {};
 
-            let compileResult = compile(rootFileNames, compilerOptions, compilerHost);
+            const compileResult = compile(rootFileNames, compilerOptions, compilerHost);
 
             if (!compilerOptions.watch) {
                 return sys.exit(compileResult.exitStatus);
@@ -311,14 +406,14 @@ namespace ts {
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
             // Return existing SourceFile object if one is available
             if (cachedProgram) {
-                let sourceFile = cachedProgram.getSourceFile(fileName);
+                const sourceFile = cachedProgram.getSourceFile(fileName);
                 // A modified source file has no watcher and should not be reused
                 if (sourceFile && sourceFile.fileWatcher) {
                     return sourceFile;
                 }
             }
             // Use default host function
-            let sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
+            const sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
             if (sourceFile && compilerOptions.watch) {
                 // Attach a file watcher
                 sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (fileName: string, removed?: boolean) => sourceFileChanged(sourceFile, removed));
@@ -329,7 +424,7 @@ namespace ts {
         // Change cached program to the given program
         function setCachedProgram(program: Program) {
             if (cachedProgram) {
-                let newSourceFiles = program ? program.getSourceFiles() : undefined;
+                const newSourceFiles = program ? program.getSourceFiles() : undefined;
                 forEach(cachedProgram.getSourceFiles(), sourceFile => {
                     if (!(newSourceFiles && contains(newSourceFiles, sourceFile))) {
                         if (sourceFile.fileWatcher) {
@@ -347,7 +442,7 @@ namespace ts {
             sourceFile.fileWatcher.close();
             sourceFile.fileWatcher = undefined;
             if (removed) {
-                let index = rootFileNames.indexOf(sourceFile.fileName);
+                const index = rootFileNames.indexOf(sourceFile.fileName);
                 if (index >= 0) {
                     rootFileNames.splice(index, 1);
                 }
@@ -378,9 +473,9 @@ namespace ts {
         }
 
         function directoryChangeHandler() {
-            let parsedCommandLine = parseConfigFile();
-            let newFileNames = ts.map(parsedCommandLine.fileNames, compilerHost.getCanonicalFileName);
-            let canonicalRootFileNames = ts.map(rootFileNames, compilerHost.getCanonicalFileName);
+            const parsedCommandLine = parseConfigFile();
+            const newFileNames = ts.map(parsedCommandLine.fileNames, compilerHost.getCanonicalFileName);
+            const canonicalRootFileNames = ts.map(rootFileNames, compilerHost.getCanonicalFileName);
 
             // We check if the project file list has changed. If so, we just throw away the old program and start fresh.
             if (!arrayIsEqualTo(newFileNames && newFileNames.sort(), canonicalRootFileNames && canonicalRootFileNames.sort())) {
@@ -414,8 +509,8 @@ namespace ts {
         checkTime = 0;
         emitTime = 0;
 
-        let program = createProgram(fileNames, compilerOptions, compilerHost);
-        let exitStatus = compileProgram();
+        const program = createProgram(fileNames, compilerOptions, compilerHost);
+        const exitStatus = compileProgram();
 
         if (compilerOptions.listFiles) {
             forEach(program.getSourceFiles(), file => {
@@ -424,7 +519,7 @@ namespace ts {
         }
 
         if (compilerOptions.diagnostics) {
-            let memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
+            const memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
             reportCountStatistic("Files", program.getSourceFiles().length);
             reportCountStatistic("Lines", countLines(program));
             reportCountStatistic("Nodes", program.getNodeCount());
@@ -477,7 +572,7 @@ namespace ts {
             }
 
             // Otherwise, emit and report any errors we ran into.
-            let emitOutput = program.emit();
+            const emitOutput = program.emit();
             reportDiagnostics(emitOutput.diagnostics, compilerHost);
 
             // If the emitter didn't emit anything, then pass that value along.
@@ -503,8 +598,8 @@ namespace ts {
         let output = "";
 
         // We want to align our "syntax" and "examples" commands to a certain margin.
-        let syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length;
-        let examplesLength = getDiagnosticText(Diagnostics.Examples_Colon_0, "").length;
+        const syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length;
+        const examplesLength = getDiagnosticText(Diagnostics.Examples_Colon_0, "").length;
         let marginLength = Math.max(syntaxLength, examplesLength);
 
         // Build up the syntactic skeleton.
@@ -515,7 +610,7 @@ namespace ts {
         output += sys.newLine + sys.newLine;
 
         // Build up the list of examples.
-        let padding = makePadding(marginLength);
+        const padding = makePadding(marginLength);
         output += getDiagnosticText(Diagnostics.Examples_Colon_0, makePadding(marginLength - examplesLength) + "tsc hello.ts") + sys.newLine;
         output += padding + "tsc --out file.js file.ts" + sys.newLine;
         output += padding + "tsc @args.txt" + sys.newLine;
@@ -524,17 +619,17 @@ namespace ts {
         output += getDiagnosticText(Diagnostics.Options_Colon) + sys.newLine;
 
         // Sort our options by their names, (e.g. "--noImplicitAny" comes before "--watch")
-        let optsList = filter(optionDeclarations.slice(), v => !v.experimental);
+        const optsList = filter(optionDeclarations.slice(), v => !v.experimental);
         optsList.sort((a, b) => compareValues<string>(a.name.toLowerCase(), b.name.toLowerCase()));
 
         // We want our descriptions to align at the same column in our output,
         // so we keep track of the longest option usage string.
         marginLength = 0;
-        let usageColumn: string[] = []; // Things like "-d, --declaration" go in here.
-        let descriptionColumn: string[] = [];
+        const usageColumn: string[] = []; // Things like "-d, --declaration" go in here.
+        const descriptionColumn: string[] = [];
 
         for (let i = 0; i < optsList.length; i++) {
-            let option = optsList[i];
+            const option = optsList[i];
 
             // If an option lacks a description,
             // it is not officially supported.
@@ -560,15 +655,15 @@ namespace ts {
         }
 
         // Special case that can't fit in the loop.
-        let usageText = " @<" + getDiagnosticText(Diagnostics.file) + ">";
+        const usageText = " @<" + getDiagnosticText(Diagnostics.file) + ">";
         usageColumn.push(usageText);
         descriptionColumn.push(getDiagnosticText(Diagnostics.Insert_command_line_options_and_files_from_a_file));
         marginLength = Math.max(usageText.length, marginLength);
 
         // Print out each row, aligning all the descriptions on the same column.
         for (let i = 0; i < usageColumn.length; i++) {
-            let usage = usageColumn[i];
-            let description = descriptionColumn[i];
+            const usage = usageColumn[i];
+            const description = descriptionColumn[i];
             output += usage + makePadding(marginLength - usage.length + 2) + description + sys.newLine;
         }
 
@@ -588,14 +683,14 @@ namespace ts {
     }
 
     function writeConfigFile(options: CompilerOptions, fileNames: string[]) {
-        let currentDirectory = sys.getCurrentDirectory();
-        let file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
+        const currentDirectory = sys.getCurrentDirectory();
+        const file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
         if (sys.fileExists(file)) {
             reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), /* compilerHost */ undefined);
         }
         else {
-            let compilerOptions = extend(options, defaultInitCompilerOptions);
-            let configurations: any = {
+            const compilerOptions = extend(options, defaultInitCompilerOptions);
+            const configurations: any = {
                 compilerOptions: serializeCompilerOptions(compilerOptions),
                 exclude: ["node_modules"]
             };
@@ -612,12 +707,12 @@ namespace ts {
         return;
 
         function serializeCompilerOptions(options: CompilerOptions): Map<string | number | boolean> {
-            let result: Map<string | number | boolean> = {};
-            let optionsNameMap = getOptionNameMap().optionNameMap;
+            const result: Map<string | number | boolean> = {};
+            const optionsNameMap = getOptionNameMap().optionNameMap;
 
-            for (let name in options) {
+            for (const name in options) {
                 if (hasProperty(options, name)) {
-                    let value = options[name];
+                    const value = options[name];
                     switch (name) {
                         case "init":
                         case "watch":
@@ -634,8 +729,8 @@ namespace ts {
                                 }
                                 else {
                                     // Enum
-                                    let typeMap = <Map<number>>optionDefinition.type;
-                                    for (let key in typeMap) {
+                                    const typeMap = <Map<number>>optionDefinition.type;
+                                    for (const key in typeMap) {
                                         if (hasProperty(typeMap, key)) {
                                             if (typeMap[key] === value)
                                                 result[name] = key;
diff --git a/src/compiler/tsconfig.json b/src/compiler/tsconfig.json
index fd541a8ca80..ca297c087cf 100644
--- a/src/compiler/tsconfig.json
+++ b/src/compiler/tsconfig.json
@@ -11,6 +11,7 @@
         "core.ts",
         "sys.ts",
         "types.ts",
+        "diagnosticInformationMap.generated.ts",
         "scanner.ts",
         "parser.ts",
         "utilities.ts",
@@ -19,7 +20,6 @@
         "emitter.ts",
         "program.ts",
         "commandLineParser.ts",
-        "tsc.ts",
-        "diagnosticInformationMap.generated.ts"
+        "tsc.ts"
     ]
 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 4295a179132..98729f01ab3 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -367,28 +367,31 @@ namespace ts {
 
     export const enum NodeFlags {
         None =              0,
-        Export =            0x00000001,  // Declarations
-        Ambient =           0x00000002,  // Declarations
-        Public =            0x00000010,  // Property/Method
-        Private =           0x00000020,  // Property/Method
-        Protected =         0x00000040,  // Property/Method
-        Static =            0x00000080,  // Property/Method
-        Abstract =          0x00000100,  // Class/Method/ConstructSignature
-        Async =             0x00000200,  // Property/Method/Function
-        Default =           0x00000400,  // Function/Class (export default declaration)
-        MultiLine =         0x00000800,  // Multi-line array or object literal
-        Synthetic =         0x00001000,  // Synthetic node (for full fidelity)
-        DeclarationFile =   0x00002000,  // Node is a .d.ts file
-        Let =               0x00004000,  // Variable declaration
-        Const =             0x00008000,  // Variable declaration
-        OctalLiteral =      0x00010000,  // Octal numeric literal
-        Namespace =         0x00020000,  // Namespace declaration
-        ExportContext =     0x00040000,  // Export context (initialized by binding)
-        ContainsThis =      0x00080000,  // Interface contains references to "this"
-
+        Export =            1 << 1,  // Declarations
+        Ambient =           1 << 2,  // Declarations
+        Public =            1 << 3,  // Property/Method
+        Private =           1 << 4,  // Property/Method
+        Protected =         1 << 5,  // Property/Method
+        Static =            1 << 6,  // Property/Method
+        Abstract =          1 << 7,  // Class/Method/ConstructSignature
+        Async =             1 << 8,  // Property/Method/Function
+        Default =           1 << 9,  // Function/Class (export default declaration)
+        MultiLine =         1 << 10,  // Multi-line array or object literal
+        Synthetic =         1 << 11,  // Synthetic node (for full fidelity)
+        DeclarationFile =   1 << 12,  // Node is a .d.ts file
+        Let =               1 << 13,  // Variable declaration
+        Const =             1 << 14,  // Variable declaration
+        OctalLiteral =      1 << 15,  // Octal numeric literal
+        Namespace =         1 << 16,  // Namespace declaration
+        ExportContext =     1 << 17,  // Export context (initialized by binding)
+        ContainsThis =      1 << 18,  // Interface contains references to "this"
+        HasImplicitReturn =     1 << 19,  // If function implicitly returns on one of codepaths (initialized by binding)
+        HasExplicitReturn =     1 << 20,  // If function has explicit reachable return on one of codepaths (initialized by binding)
         Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async,
         AccessibilityModifier = Public | Private | Protected,
-        BlockScoped = Let | Const
+        BlockScoped = Let | Const,
+
+        ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn
     }
 
     /* @internal */
@@ -2084,6 +2087,7 @@ namespace ts {
         outFile?: string;
         outDir?: string;
         preserveConstEnums?: boolean;
+        /* @internal */ pretty?: DiagnosticStyle;
         project?: string;
         removeComments?: boolean;
         rootDir?: string;
@@ -2098,6 +2102,10 @@ namespace ts {
         experimentalDecorators?: boolean;
         emitDecoratorMetadata?: boolean;
         moduleResolution?: ModuleResolutionKind;
+        allowUnusedLabels?: boolean;
+        allowUnreachableCode?: boolean;
+        noImplicitReturns?: boolean;
+        noFallthroughCasesInSwitch?: boolean;
         forceConsistentCasingInFileNames?: boolean;
         allowJs?: boolean;
         /* @internal */ stripInternal?: boolean;
@@ -2150,6 +2158,12 @@ namespace ts {
         JSX,
     }
 
+    /* @internal */
+    export const enum DiagnosticStyle {
+        Simple,
+        Pretty,
+    }
+
     export interface ParsedCommandLine {
         options: CompilerOptions;
         fileNames: string[];
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 1af18476e7e..be70e106498 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -16,9 +16,9 @@ namespace ts {
     }
 
     export function getDeclarationOfKind(symbol: Symbol, kind: SyntaxKind): Declaration {
-        let declarations = symbol.declarations;
+        const declarations = symbol.declarations;
         if (declarations) {
-            for (let declaration of declarations) {
+            for (const declaration of declarations) {
                 if (declaration.kind === kind) {
                     return declaration;
                 }
@@ -45,12 +45,12 @@ namespace ts {
     }
 
     // Pool writers to avoid needing to allocate them for every symbol we write.
-    let stringWriters: StringSymbolWriter[] = [];
+    const stringWriters: StringSymbolWriter[] = [];
     export function getSingleLineStringWriter(): StringSymbolWriter {
         if (stringWriters.length === 0) {
             let str = "";
 
-            let writeText: (text: string) => void = text => str += text;
+            const writeText: (text: string) => void = text => str += text;
             return {
                 string: () => str,
                 writeKeyword: writeText,
@@ -94,7 +94,7 @@ namespace ts {
         }
 
         for (let i = 0; i < array1.length; ++i) {
-            let equals = equaler ? equaler(array1[i], array2[i]) : array1[i] === array2[i];
+            const equals = equaler ? equaler(array1[i], array2[i]) : array1[i] === array2[i];
             if (!equals) {
                 return false;
             }
@@ -130,7 +130,7 @@ namespace ts {
             // A node is considered to contain a parse error if:
             //  a) the parser explicitly marked that it had an error
             //  b) any of it's children reported that it had an error.
-            let thisNodeOrAnySubNodesHasError = ((node.parserContextFlags & ParserContextFlags.ThisNodeHasError) !== 0) ||
+            const thisNodeOrAnySubNodesHasError = ((node.parserContextFlags & ParserContextFlags.ThisNodeHasError) !== 0) ||
                 forEachChild(node, containsParseError);
 
             // If so, mark ourselves accordingly.
@@ -159,8 +159,8 @@ namespace ts {
 
     // This is a useful function for debugging purposes.
     export function nodePosToString(node: Node): string {
-        let file = getSourceFileOfNode(node);
-        let loc = getLineAndCharacterOfPosition(file, node.pos);
+        const file = getSourceFileOfNode(node);
+        const loc = getLineAndCharacterOfPosition(file, node.pos);
         return `${ file.fileName }(${ loc.line + 1 },${ loc.character + 1 })`;
     }
 
@@ -215,7 +215,7 @@ namespace ts {
             return "";
         }
 
-        let text = sourceFile.text;
+        const text = sourceFile.text;
         return text.substring(includeTrivia ? node.pos : skipTrivia(text, node.pos), node.end);
     }
 
@@ -296,14 +296,14 @@ namespace ts {
     }
 
     export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic {
-        let sourceFile = getSourceFileOfNode(node);
-        let span = getErrorSpanForNode(sourceFile, node);
+        const sourceFile = getSourceFileOfNode(node);
+        const span = getErrorSpanForNode(sourceFile, node);
         return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2);
     }
 
     export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain): Diagnostic {
-        let sourceFile = getSourceFileOfNode(node);
-        let span = getErrorSpanForNode(sourceFile, node);
+        const sourceFile = getSourceFileOfNode(node);
+        const span = getErrorSpanForNode(sourceFile, node);
         return {
             file: sourceFile,
             start: span.start,
@@ -315,9 +315,9 @@ namespace ts {
     }
 
     export function getSpanOfTokenAtPosition(sourceFile: SourceFile, pos: number): TextSpan {
-        let scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos);
+        const scanner = createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos);
         scanner.scan();
-        let start = scanner.getTokenPos();
+        const start = scanner.getTokenPos();
         return createTextSpanFromBounds(start, scanner.getTextPos());
     }
 
@@ -353,7 +353,7 @@ namespace ts {
             return getSpanOfTokenAtPosition(sourceFile, node.pos);
         }
 
-        let pos = nodeIsMissing(errorNode)
+        const pos = nodeIsMissing(errorNode)
             ? errorNode.pos
             : skipTrivia(sourceFile.text, errorNode.pos);
 
@@ -424,7 +424,7 @@ namespace ts {
     }
 
     export function getJsDocComments(node: Node, sourceFileOfNode: SourceFile) {
-        let commentRanges = (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) ?
+        const commentRanges = (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) ?
             concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos),
                 getLeadingCommentRanges(sourceFileOfNode.text, node.pos)) :
             getLeadingCommentRangesOfNode(node, sourceFileOfNode);
@@ -581,7 +581,7 @@ namespace ts {
                     return;
                 default:
                     if (isFunctionLike(node)) {
-                        let name = (<FunctionLikeDeclaration>node).name;
+                        const name = (<FunctionLikeDeclaration>node).name;
                         if (name && name.kind === SyntaxKind.ComputedPropertyName) {
                             // Note that we will not include methods/accessors of a class because they would require
                             // first descending into the class. This is by design.
@@ -624,25 +624,26 @@ namespace ts {
     }
 
     export function isFunctionLike(node: Node): node is FunctionLikeDeclaration {
-        if (node) {
-            switch (node.kind) {
-                case SyntaxKind.Constructor:
-                case SyntaxKind.FunctionExpression:
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.ArrowFunction:
-                case SyntaxKind.MethodDeclaration:
-                case SyntaxKind.MethodSignature:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                case SyntaxKind.CallSignature:
-                case SyntaxKind.ConstructSignature:
-                case SyntaxKind.IndexSignature:
-                case SyntaxKind.FunctionType:
-                case SyntaxKind.ConstructorType:
-                    return true;
-            }
+        return node && isFunctionLikeKind(node.kind);
+    }
+
+    export function isFunctionLikeKind(kind: SyntaxKind): boolean {
+        switch (kind) {
+            case SyntaxKind.Constructor:
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+            case SyntaxKind.CallSignature:
+            case SyntaxKind.ConstructSignature:
+            case SyntaxKind.IndexSignature:
+            case SyntaxKind.FunctionType:
+            case SyntaxKind.ConstructorType:
+                return true;
         }
-        return false;
     }
 
     export function introducesArgumentsExoticObject(node: Node) {
@@ -1031,7 +1032,7 @@ namespace ts {
     }
 
     export function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean) {
-        let moduleState = getModuleInstanceState(node);
+        const moduleState = getModuleInstanceState(node);
         return moduleState === ModuleInstanceState.Instantiated ||
             (preserveConstEnums && moduleState === ModuleInstanceState.ConstEnumOnly);
     }
@@ -1054,7 +1055,7 @@ namespace ts {
             return (<ImportDeclaration>node).moduleSpecifier;
         }
         if (node.kind === SyntaxKind.ImportEqualsDeclaration) {
-            let reference = (<ImportEqualsDeclaration>node).moduleReference;
+            const reference = (<ImportEqualsDeclaration>node).moduleReference;
             if (reference.kind === SyntaxKind.ExternalModuleReference) {
                 return (<ExternalModuleReference>reference).expression;
             }
@@ -1089,7 +1090,7 @@ namespace ts {
 
     function getJSDocTag(node: Node, kind: SyntaxKind): JSDocTag {
         if (node && node.jsDocComment) {
-            for (let tag of node.jsDocComment.tags) {
+            for (const tag of node.jsDocComment.tags) {
                 if (tag.kind === kind) {
                     return tag;
                 }
@@ -1113,14 +1114,14 @@ namespace ts {
         if (parameter.name && parameter.name.kind === SyntaxKind.Identifier) {
             // If it's a parameter, see if the parent has a jsdoc comment with an @param
             // annotation.
-            let parameterName = (<Identifier>parameter.name).text;
+            const parameterName = (<Identifier>parameter.name).text;
 
-            let docComment = parameter.parent.jsDocComment;
+            const docComment = parameter.parent.jsDocComment;
             if (docComment) {
                 return <JSDocParameterTag>forEach(docComment.tags, t => {
                     if (t.kind === SyntaxKind.JSDocParameterTag) {
-                        let parameterTag = <JSDocParameterTag>t;
-                        let name = parameterTag.preParameterName || parameterTag.postParameterName;
+                        const parameterTag = <JSDocParameterTag>t;
+                        const name = parameterTag.preParameterName || parameterTag.postParameterName;
                         if (name.text === parameterName) {
                             return t;
                         }
@@ -1141,7 +1142,7 @@ namespace ts {
                     return true;
                 }
 
-                let paramTag = getCorrespondingJSDocParameterTag(node);
+                const paramTag = getCorrespondingJSDocParameterTag(node);
                 if (paramTag && paramTag.typeExpression) {
                     return paramTag.typeExpression.type.kind === SyntaxKind.JSDocVariadicType;
                 }
@@ -1169,6 +1170,14 @@ namespace ts {
         return !!node && (node.kind === SyntaxKind.ArrayBindingPattern || node.kind === SyntaxKind.ObjectBindingPattern);
     }
 
+    export function isNodeDescendentOf(node: Node, ancestor: Node): boolean {
+        while (node) {
+            if (node === ancestor) return true;
+            node = node.parent;
+        }
+        return false;
+    }
+
     export function isInAmbientContext(node: Node): boolean {
         while (node) {
             if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) {
@@ -1230,7 +1239,7 @@ namespace ts {
             case SyntaxKind.LabeledStatement:
             case SyntaxKind.ReturnStatement:
             case SyntaxKind.SwitchStatement:
-            case SyntaxKind.ThrowKeyword:
+            case SyntaxKind.ThrowStatement:
             case SyntaxKind.TryStatement:
             case SyntaxKind.VariableStatement:
             case SyntaxKind.WhileStatement:
@@ -1263,7 +1272,7 @@ namespace ts {
             return false;
         }
 
-        let parent = name.parent;
+        const parent = name.parent;
         if (parent.kind === SyntaxKind.ImportSpecifier || parent.kind === SyntaxKind.ExportSpecifier) {
             if ((<ImportOrExportSpecifier>parent).propertyName) {
                 return true;
@@ -1330,23 +1339,23 @@ namespace ts {
     }
 
     export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration) {
-        let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
+        const heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
         return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
     }
 
     export function getClassImplementsHeritageClauseElements(node: ClassLikeDeclaration) {
-        let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
+        const heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
         return heritageClause ? heritageClause.types : undefined;
     }
 
     export function getInterfaceBaseTypeNodes(node: InterfaceDeclaration) {
-        let heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
+        const heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
         return heritageClause ? heritageClause.types : undefined;
     }
 
     export function getHeritageClause(clauses: NodeArray<HeritageClause>, kind: SyntaxKind) {
         if (clauses) {
-            for (let clause of clauses) {
+            for (const clause of clauses) {
                 if (clause.token === kind) {
                     return clause;
                 }
@@ -1358,7 +1367,7 @@ namespace ts {
 
     export function tryResolveScriptReference(host: ScriptReferenceHost, sourceFile: SourceFile, reference: FileReference) {
         if (!host.getCompilerOptions().noResolve) {
-            let referenceFileName = isRootedDiskPath(reference.fileName) ? reference.fileName : combinePaths(getDirectoryPath(sourceFile.fileName), reference.fileName);
+            const referenceFileName = isRootedDiskPath(reference.fileName) ? reference.fileName : combinePaths(getDirectoryPath(sourceFile.fileName), reference.fileName);
             return host.getSourceFile(referenceFileName);
         }
     }
@@ -1374,8 +1383,8 @@ namespace ts {
     }
 
     export function getFileReferenceFromReferencePath(comment: string, commentRange: CommentRange): ReferencePathMatchResult {
-        let simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
-        let isNoDefaultLibRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/gim;
+        const simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
+        const isNoDefaultLibRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/gim;
         if (simpleReferenceRegEx.exec(comment)) {
             if (isNoDefaultLibRegEx.exec(comment)) {
                 return {
@@ -1383,10 +1392,10 @@ namespace ts {
                 };
             }
             else {
-                let matchResult = fullTripleSlashReferencePathRegEx.exec(comment);
+                const matchResult = fullTripleSlashReferencePathRegEx.exec(comment);
                 if (matchResult) {
-                    let start = commentRange.pos;
-                    let end = commentRange.end;
+                    const start = commentRange.pos;
+                    const end = commentRange.end;
                     return {
                         fileReference: {
                             pos: start,
@@ -1447,9 +1456,9 @@ namespace ts {
             return (<Identifier | LiteralExpression>name).text;
         }
         if (name.kind === SyntaxKind.ComputedPropertyName) {
-            let nameExpression = (<ComputedPropertyName>name).expression;
+            const nameExpression = (<ComputedPropertyName>name).expression;
             if (isWellKnownSymbolSyntactically(nameExpression)) {
-                let rightHandSideName = (<PropertyAccessExpression>nameExpression).name.text;
+                const rightHandSideName = (<PropertyAccessExpression>nameExpression).name.text;
                 return getPropertyNameForKnownSymbolName(rightHandSideName);
             }
         }
@@ -1486,7 +1495,7 @@ namespace ts {
     }
 
     export function isParameterDeclaration(node: VariableLikeDeclaration) {
-        let root = getRootDeclaration(node);
+        const root = getRootDeclaration(node);
         return root.kind === SyntaxKind.Parameter;
     }
 
@@ -1503,12 +1512,12 @@ namespace ts {
 
     export function cloneEntityName(node: EntityName): EntityName {
         if (node.kind === SyntaxKind.Identifier) {
-            let clone = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
+            const clone = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
             clone.text = (<Identifier>node).text;
             return clone;
         }
         else {
-            let clone = <QualifiedName>createSynthesizedNode(SyntaxKind.QualifiedName);
+            const clone = <QualifiedName>createSynthesizedNode(SyntaxKind.QualifiedName);
             clone.left = cloneEntityName((<QualifiedName>node).left);
             clone.left.parent = clone;
             clone.right = <Identifier>cloneEntityName((<QualifiedName>node).right);
@@ -1522,13 +1531,13 @@ namespace ts {
     }
 
     export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node {
-        let node = <SynthesizedNode>createNode(kind, /* pos */ -1, /* end */ -1);
+        const node = <SynthesizedNode>createNode(kind, /* pos */ -1, /* end */ -1);
         node.startsOnNewLine = startsOnNewLine;
         return node;
     }
 
     export function createSynthesizedNodeArray(): NodeArray<any> {
-        let array = <NodeArray<any>>[];
+        const array = <NodeArray<any>>[];
         array.pos = -1;
         array.end = -1;
         return array;
@@ -1536,7 +1545,7 @@ namespace ts {
 
     export function createDiagnosticCollection(): DiagnosticCollection {
         let nonFileDiagnostics: Diagnostic[] = [];
-        let fileDiagnostics: Map<Diagnostic[]> = {};
+        const fileDiagnostics: Map<Diagnostic[]> = {};
 
         let diagnosticsModified = false;
         let modificationCount = 0;
@@ -1558,7 +1567,7 @@ namespace ts {
                 return;
             }
 
-            for (let diagnostic of fileDiagnostics[newFile.fileName]) {
+            for (const diagnostic of fileDiagnostics[newFile.fileName]) {
                 diagnostic.file = newFile;
             }
         }
@@ -1592,14 +1601,14 @@ namespace ts {
                 return fileDiagnostics[fileName] || [];
             }
 
-            let allDiagnostics: Diagnostic[] = [];
+            const allDiagnostics: Diagnostic[] = [];
             function pushDiagnostic(d: Diagnostic) {
                 allDiagnostics.push(d);
             }
 
             forEach(nonFileDiagnostics, pushDiagnostic);
 
-            for (let key in fileDiagnostics) {
+            for (const key in fileDiagnostics) {
                 if (hasProperty(fileDiagnostics, key)) {
                     forEach(fileDiagnostics[key], pushDiagnostic);
                 }
@@ -1616,7 +1625,7 @@ namespace ts {
             diagnosticsModified = false;
             nonFileDiagnostics = sortAndDeduplicateDiagnostics(nonFileDiagnostics);
 
-            for (let key in fileDiagnostics) {
+            for (const key in fileDiagnostics) {
                 if (hasProperty(fileDiagnostics, key)) {
                     fileDiagnostics[key] = sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
                 }
@@ -1629,8 +1638,8 @@ namespace ts {
     // the language service. These characters should be escaped when printing, and if any characters are added,
     // the map below must be updated. Note that this regexp *does not* include the 'delete' character.
     // There is no reason for this other than that JSON.stringify does not handle it either.
-    let escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    let escapedCharsMap: Map<string> = {
+    const escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
+    const escapedCharsMap: Map<string> = {
         "\0": "\\0",
         "\t": "\\t",
         "\v": "\\v",
@@ -1661,17 +1670,17 @@ namespace ts {
     }
 
     export function isIntrinsicJsxName(name: string) {
-        let ch = name.substr(0, 1);
+        const ch = name.substr(0, 1);
         return ch.toLowerCase() === ch;
     }
 
     function get16BitUnicodeEscapeSequence(charCode: number): string {
-        let hexCharCode = charCode.toString(16).toUpperCase();
-        let paddedHexCode = ("0000" + hexCharCode).slice(-4);
+        const hexCharCode = charCode.toString(16).toUpperCase();
+        const paddedHexCode = ("0000" + hexCharCode).slice(-4);
         return "\\u" + paddedHexCode;
     }
 
-    let nonAsciiCharacters = /[^\u0000-\u007F]/g;
+    const nonAsciiCharacters = /[^\u0000-\u007F]/g;
     export function escapeNonAsciiCharacters(s: string): string {
         // Replace non-ASCII characters with '\uNNNN' escapes if any exist.
         // Otherwise just return the original string.
@@ -1695,7 +1704,7 @@ namespace ts {
         getIndent(): number;
     }
 
-    let indentStrings: string[] = ["", "    "];
+    const indentStrings: string[] = ["", "    "];
     export function getIndentString(level: number) {
         if (indentStrings[level] === undefined) {
             indentStrings[level] = getIndentString(level - 1) + indentStrings[1];
@@ -1736,7 +1745,7 @@ namespace ts {
         function writeLiteral(s: string) {
             if (s && s.length) {
                 write(s);
-                let lineStartsOfS = computeLineStarts(s);
+                const lineStartsOfS = computeLineStarts(s);
                 if (lineStartsOfS.length > 1) {
                     lineCount = lineCount + lineStartsOfS.length - 1;
                     linePos = output.length - s.length + lastOrUndefined(lineStartsOfS);
@@ -1774,7 +1783,7 @@ namespace ts {
     }
 
     export function getOwnEmitOutputFilePath(sourceFile: SourceFile, host: EmitHost, extension: string) {
-        let compilerOptions = host.getCompilerOptions();
+        const compilerOptions = host.getCompilerOptions();
         let emitOutputFilePathWithoutExtension: string;
         if (compilerOptions.outDir) {
             emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(sourceFile, host, compilerOptions.outDir));
@@ -1795,7 +1804,7 @@ namespace ts {
     export function forEachExpectedEmitFile(host: EmitHost,
         action: (emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean) => void,
         targetSourceFile?: SourceFile) {
-        let options = host.getCompilerOptions();
+        const options = host.getCompilerOptions();
         if (targetSourceFile === undefined) {
             // Emit on each source file
             forEach(host.getSourceFiles(), sourceFile => {
@@ -1819,9 +1828,9 @@ namespace ts {
         }
 
         function onSingleFileEmit(host: EmitHost, sourceFile: SourceFile) {
-            let jsFilePath = getOwnEmitOutputFilePath(sourceFile, host,
+            const jsFilePath = getOwnEmitOutputFilePath(sourceFile, host,
                 sourceFile.languageVariant === LanguageVariant.JSX && options.jsx === JsxEmit.Preserve ? ".jsx" : ".js");
-            let emitFileNames: EmitFileNames = {
+            const emitFileNames: EmitFileNames = {
                 jsFilePath,
                 sourceMapFilePath: getSourceMapFilePath(jsFilePath, options),
                 declarationFilePath: !isJavaScript(sourceFile.fileName) ? getDeclarationEmitFilePath(jsFilePath, options) : undefined
@@ -1830,10 +1839,10 @@ namespace ts {
         }
 
         function onBundledEmit(host: EmitHost) {
-            let bundledSources = filter(host.getSourceFiles(),
+            const bundledSources = filter(host.getSourceFiles(),
                 sourceFile => !shouldEmitToOwnFile(sourceFile, options) && !isDeclarationFile(sourceFile));
-            let jsFilePath = options.outFile || options.out;
-            let emitFileNames: EmitFileNames = {
+            const jsFilePath = options.outFile || options.out;
+            const emitFileNames: EmitFileNames = {
                 jsFilePath,
                 sourceMapFilePath: getSourceMapFilePath(jsFilePath, options),
                 declarationFilePath: getDeclarationEmitFilePath(jsFilePath, options)
@@ -1914,8 +1923,8 @@ namespace ts {
             forEach(declarations, (member: Declaration) => {
                 if ((member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor)
                     && (member.flags & NodeFlags.Static) === (accessor.flags & NodeFlags.Static)) {
-                    let memberName = getPropertyNameForPropertyNameNode(member.name);
-                    let accessorName = getPropertyNameForPropertyNameNode(accessor.name);
+                    const memberName = getPropertyNameForPropertyNameNode(member.name);
+                    const accessorName = getPropertyNameForPropertyNameNode(accessor.name);
                     if (memberName === accessorName) {
                         if (!firstAccessor) {
                             firstAccessor = <AccessorDeclaration>member;
@@ -1973,13 +1982,81 @@ namespace ts {
         });
     }
 
+    /**
+     * Detached comment is a comment at the top of file or function body that is separated from
+     * the next statement by space.
+     */
+    export function emitDetachedComments(currentSourceFile: SourceFile, writer: EmitTextWriter,
+        writeComment: (currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) => void,
+        node: TextRange, newLine: string, removeComments: boolean) {
+        let leadingComments: CommentRange[];
+        let currentDetachedCommentInfo: {nodePos: number, detachedCommentEndPos: number};
+        if (removeComments) {
+            // removeComments is true, only reserve pinned comment at the top of file
+            // For example:
+            //      /*! Pinned Comment */
+            //
+            //      var x = 10;
+            if (node.pos === 0) {
+                leadingComments = filter(getLeadingCommentRanges(currentSourceFile.text, node.pos), isPinnedComment);
+            }
+        }
+        else {
+            // removeComments is false, just get detached as normal and bypass the process to filter comment
+            leadingComments = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+        }
+
+        if (leadingComments) {
+            const detachedComments: CommentRange[] = [];
+            let lastComment: CommentRange;
+
+            for (const comment of leadingComments) {
+                if (lastComment) {
+                    const lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastComment.end);
+                    const commentLine = getLineOfLocalPosition(currentSourceFile, comment.pos);
+
+                    if (commentLine >= lastCommentLine + 2) {
+                        // There was a blank line between the last comment and this comment.  This
+                        // comment is not part of the copyright comments.  Return what we have so
+                        // far.
+                        break;
+                    }
+                }
+
+                detachedComments.push(comment);
+                lastComment = comment;
+            }
+
+            if (detachedComments.length) {
+                // All comments look like they could have been part of the copyright header.  Make
+                // sure there is at least one blank line between it and the node.  If not, it's not
+                // a copyright header.
+                const lastCommentLine = getLineOfLocalPosition(currentSourceFile, lastOrUndefined(detachedComments).end);
+                const nodeLine = getLineOfLocalPosition(currentSourceFile, skipTrivia(currentSourceFile.text, node.pos));
+                if (nodeLine >= lastCommentLine + 2) {
+                    // Valid detachedComments
+                    emitNewLineBeforeLeadingComments(currentSourceFile, writer, node, leadingComments);
+                    emitComments(currentSourceFile, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
+                    currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: lastOrUndefined(detachedComments).end };
+                }
+            }
+        }
+
+        return currentDetachedCommentInfo;
+
+        function isPinnedComment(comment: CommentRange) {
+            return currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
+                currentSourceFile.text.charCodeAt(comment.pos + 2) === CharacterCodes.exclamation;
+        }
+    }
+
     export function writeCommentRange(currentSourceFile: SourceFile, writer: EmitTextWriter, comment: CommentRange, newLine: string) {
         if (currentSourceFile.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk) {
-            let firstCommentLineAndCharacter = getLineAndCharacterOfPosition(currentSourceFile, comment.pos);
-            let lineCount = getLineStarts(currentSourceFile).length;
+            const firstCommentLineAndCharacter = getLineAndCharacterOfPosition(currentSourceFile, comment.pos);
+            const lineCount = getLineStarts(currentSourceFile).length;
             let firstCommentLineIndent: number;
             for (let pos = comment.pos, currentLine = firstCommentLineAndCharacter.line; pos < comment.end; currentLine++) {
-                let nextLineStart = (currentLine + 1) === lineCount
+                const nextLineStart = (currentLine + 1) === lineCount
                     ? currentSourceFile.text.length + 1
                     : getStartPositionOfLine(currentLine + 1, currentSourceFile);
 
@@ -1990,7 +2067,7 @@ namespace ts {
                     }
 
                     // These are number of spaces writer is going to write at current indent
-                    let currentWriterIndentSpacing = writer.getIndent() * getIndentSize();
+                    const currentWriterIndentSpacing = writer.getIndent() * getIndentSize();
 
                     // Number of spaces we want to be writing
                     // eg: Assume writer indent
@@ -2006,10 +2083,10 @@ namespace ts {
                     //            More right indented comment */                  --4 = 8 - 4 + 11
                     //     class c { }
                     // }
-                    let spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(pos, nextLineStart);
+                    const spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(pos, nextLineStart);
                     if (spacesToEmit > 0) {
                         let numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();
-                        let indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());
+                        const indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());
 
                         // Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces
                         writer.rawWrite(indentSizeSpaceString);
@@ -2038,8 +2115,8 @@ namespace ts {
         }
 
         function writeTrimmedCurrentLine(pos: number, nextLineStart: number) {
-            let end = Math.min(comment.end, nextLineStart - 1);
-            let currentLineText = currentSourceFile.text.substring(pos, end).replace(/^\s+|\s+$/g, "");
+            const end = Math.min(comment.end, nextLineStart - 1);
+            const currentLineText = currentSourceFile.text.substring(pos, end).replace(/^\s+|\s+$/g, "");
             if (currentLineText) {
                 // trimmed forward and ending spaces text
                 writer.write(currentLineText);
@@ -2153,7 +2230,7 @@ namespace ts {
     }
 
     export function isEmptyObjectLiteralOrArrayLiteral(expression: Node): boolean {
-        let kind = expression.kind;
+        const kind = expression.kind;
         if (kind === SyntaxKind.ObjectLiteralExpression) {
             return (<ObjectLiteralExpression>expression).properties.length === 0;
         }
@@ -2181,11 +2258,11 @@ namespace ts {
      * representing the UTF-8 encoding of the character, and return the expanded char code list.
      */
     function getExpandedCharCodes(input: string): number[] {
-        let output: number[] = [];
-        let length = input.length;
+        const output: number[] = [];
+        const length = input.length;
 
         for (let i = 0; i < length; i++) {
-            let charCode = input.charCodeAt(i);
+            const charCode = input.charCodeAt(i);
 
             // handel utf8
             if (charCode < 0x80) {
@@ -2221,9 +2298,9 @@ namespace ts {
      */
     export function convertToBase64(input: string): string {
         let result = "";
-        let charCodes = getExpandedCharCodes(input);
+        const charCodes = getExpandedCharCodes(input);
         let i = 0;
-        let length = charCodes.length;
+        const length = charCodes.length;
         let byte1: number, byte2: number, byte3: number, byte4: number;
 
         while (i < length) {
@@ -2297,14 +2374,14 @@ namespace ts {
     }
 
     export function textSpanOverlapsWith(span: TextSpan, other: TextSpan) {
-        let overlapStart = Math.max(span.start, other.start);
-        let overlapEnd = Math.min(textSpanEnd(span), textSpanEnd(other));
+        const overlapStart = Math.max(span.start, other.start);
+        const overlapEnd = Math.min(textSpanEnd(span), textSpanEnd(other));
         return overlapStart < overlapEnd;
     }
 
     export function textSpanOverlap(span1: TextSpan, span2: TextSpan) {
-        let overlapStart = Math.max(span1.start, span2.start);
-        let overlapEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2));
+        const overlapStart = Math.max(span1.start, span2.start);
+        const overlapEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2));
         if (overlapStart < overlapEnd) {
             return createTextSpanFromBounds(overlapStart, overlapEnd);
         }
@@ -2316,13 +2393,13 @@ namespace ts {
     }
 
     export function textSpanIntersectsWith(span: TextSpan, start: number, length: number) {
-        let end = start + length;
+        const end = start + length;
         return start <= textSpanEnd(span) && end >= span.start;
     }
 
     export function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number) {
-        let end1 = start1 + length1;
-        let end2 = start2 + length2;
+        const end1 = start1 + length1;
+        const end2 = start2 + length2;
         return start2 <= end1 && end2 >= start1;
     }
 
@@ -2331,8 +2408,8 @@ namespace ts {
     }
 
     export function textSpanIntersection(span1: TextSpan, span2: TextSpan) {
-        let intersectStart = Math.max(span1.start, span2.start);
-        let intersectEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2));
+        const intersectStart = Math.max(span1.start, span2.start);
+        const intersectEnd = Math.min(textSpanEnd(span1), textSpanEnd(span2));
         if (intersectStart <= intersectEnd) {
             return createTextSpanFromBounds(intersectStart, intersectEnd);
         }
@@ -2391,14 +2468,14 @@ namespace ts {
 
         // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd }
         // as it makes things much easier to reason about.
-        let change0 = changes[0];
+        const change0 = changes[0];
 
         let oldStartN = change0.span.start;
         let oldEndN = textSpanEnd(change0.span);
         let newEndN = oldStartN + change0.newLength;
 
         for (let i = 1; i < changes.length; i++) {
-            let nextChange = changes[i];
+            const nextChange = changes[i];
 
             // Consider the following case:
             // i.e. two edits.  The first represents the text change range { { 10, 50 }, 30 }.  i.e. The span starting
@@ -2480,13 +2557,13 @@ namespace ts {
             //      newEnd3  : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2))
             // }
 
-            let oldStart1 = oldStartN;
-            let oldEnd1 = oldEndN;
-            let newEnd1 = newEndN;
+            const oldStart1 = oldStartN;
+            const oldEnd1 = oldEndN;
+            const newEnd1 = newEndN;
 
-            let oldStart2 = nextChange.span.start;
-            let oldEnd2 = textSpanEnd(nextChange.span);
-            let newEnd2 = oldStart2 + nextChange.newLength;
+            const oldStart2 = nextChange.span.start;
+            const oldEnd2 = textSpanEnd(nextChange.span);
+            const newEnd2 = oldStart2 + nextChange.newLength;
 
             oldStartN = Math.min(oldStart1, oldStart2);
             oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts
index 11c1b9a8029..84999302bb7 100644
--- a/src/harness/compilerRunner.ts
+++ b/src/harness/compilerRunner.ts
@@ -140,7 +140,7 @@ class CompilerBaselineRunner extends RunnerBase {
             it("Correct sourcemap content for " + fileName, () => {
                 if (options.sourceMap || options.inlineSourceMap) {
                     Harness.Baseline.runBaseline("Correct sourcemap content for " + fileName, justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
-                        let record = result.getSourceMapRecord();
+                        const record = result.getSourceMapRecord();
                         if (options.noEmitOnError && result.errors.length !== 0 && record === undefined) {
                             // Because of the noEmitOnError option no files are created. We need to return null because baselining isn"t required.
                             return null;
@@ -159,7 +159,7 @@ class CompilerBaselineRunner extends RunnerBase {
                     // check js output
                     Harness.Baseline.runBaseline("Correct JS output for " + fileName, justName.replace(/\.tsx?/, ".js"), () => {
                         let tsCode = "";
-                        let tsSources = otherFiles.concat(toBeCompiled);
+                        const tsSources = otherFiles.concat(toBeCompiled);
                         if (tsSources.length > 1) {
                             tsCode += "//// [" + fileName + "] ////\r\n\r\n";
                         }
@@ -184,7 +184,7 @@ class CompilerBaselineRunner extends RunnerBase {
                             }
                         }
 
-                        let declFileCompilationResult = harnessCompiler.compileDeclarationFiles(toBeCompiled, otherFiles, result, function (settings) {
+                        const declFileCompilationResult = harnessCompiler.compileDeclarationFiles(toBeCompiled, otherFiles, result, function (settings) {
                             harnessCompiler.setCompilerSettings(tcSettings);
                         }, options);
 
@@ -257,15 +257,15 @@ class CompilerBaselineRunner extends RunnerBase {
                     // These types are equivalent, but depend on what order the compiler observed
                     // certain parts of the program.
 
-                    let allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
+                    const allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
 
-                    let fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
-                    let pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
+                    const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
+                    const pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
 
-                    let fullResults: ts.Map<TypeWriterResult[]> = {};
-                    let pullResults: ts.Map<TypeWriterResult[]> = {};
+                    const fullResults: ts.Map<TypeWriterResult[]> = {};
+                    const pullResults: ts.Map<TypeWriterResult[]> = {};
 
-                    for (let sourceFile of allFiles) {
+                    for (const sourceFile of allFiles) {
                         fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
                         pullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
                     }
@@ -294,11 +294,11 @@ class CompilerBaselineRunner extends RunnerBase {
                     return;
 
                     function checkBaseLines(isSymbolBaseLine: boolean) {
-                        let fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
-                        let pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
+                        const fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
+                        const pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
 
-                        let fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
-                        let pullExtension = isSymbolBaseLine ? ".symbols.pull" : ".types.pull";
+                        const fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
+                        const pullExtension = isSymbolBaseLine ? ".symbols.pull" : ".types.pull";
 
                         if (fullBaseLine !== pullBaseLine) {
                             Harness.Baseline.runBaseline("Correct full information for " + fileName, justName.replace(/\.tsx?/, fullExtension), () => fullBaseLine);
@@ -310,24 +310,24 @@ class CompilerBaselineRunner extends RunnerBase {
                     }
 
                     function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
-                        let typeLines: string[] = [];
-                        let typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
+                        const typeLines: string[] = [];
+                        const typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
 
                         allFiles.forEach(file => {
-                            let codeLines = file.content.split("\n");
+                            const codeLines = file.content.split("\n");
                             typeWriterResults[file.unitName].forEach(result => {
                                 if (isSymbolBaseline && !result.symbol) {
                                     return;
                                 }
 
-                                let typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type;
-                                let formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString;
+                                const typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type;
+                                const formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString;
                                 if (!typeMap[file.unitName]) {
                                     typeMap[file.unitName] = {};
                                 }
 
                                 let typeInfo = [formattedLine];
-                                let existingTypeInfo = typeMap[file.unitName][result.line];
+                                const existingTypeInfo = typeMap[file.unitName][result.line];
                                 if (existingTypeInfo) {
                                     typeInfo = existingTypeInfo.concat(typeInfo);
                                 }
@@ -336,10 +336,10 @@ class CompilerBaselineRunner extends RunnerBase {
 
                             typeLines.push("=== " + file.unitName + " ===\r\n");
                             for (let i = 0; i < codeLines.length; i++) {
-                                let currentCodeLine = codeLines[i];
+                                const currentCodeLine = codeLines[i];
                                 typeLines.push(currentCodeLine + "\r\n");
                                 if (typeMap[file.unitName]) {
-                                    let typeInfo = typeMap[file.unitName][i];
+                                    const typeInfo = typeMap[file.unitName][i];
                                     if (typeInfo) {
                                         typeInfo.forEach(ty => {
                                             typeLines.push(">" + ty + "\r\n");
@@ -367,13 +367,13 @@ class CompilerBaselineRunner extends RunnerBase {
     public initializeTests() {
         describe(this.testSuiteName + " tests", () => {
             describe("Setup compiler for compiler baselines", () => {
-                let harnessCompiler = Harness.Compiler.getCompiler();
+                const harnessCompiler = Harness.Compiler.getCompiler();
                 this.parseOptions();
             });
 
             // this will set up a series of describe/it blocks to run between the setup and cleanup phases
             if (this.tests.length === 0) {
-                let testFiles = this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true });
+                const testFiles = this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true });
                 testFiles.forEach(fn => {
                     fn = fn.replace(/\\/g, "/");
                     this.checkTestCodeOutput(fn);
@@ -392,7 +392,7 @@ class CompilerBaselineRunner extends RunnerBase {
             this.decl = false;
             this.output = false;
 
-            let opts = this.options.split(",");
+            const opts = this.options.split(",");
             for (let i = 0; i < opts.length; i++) {
                 switch (opts[i]) {
                     case "error":
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index 9bf1ba01843..379b228291c 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -102,7 +102,7 @@ namespace FourSlash {
 
     export import IndentStyle = ts.IndentStyle;
 
-    let entityMap: ts.Map<string> = {
+    const entityMap: ts.Map<string> = {
         "&": "&amp;",
         "\"": "&quot;",
         "'": "&#39;",
@@ -118,7 +118,7 @@ namespace FourSlash {
     // Name of testcase metadata including ts.CompilerOptions properties that will be used by globalOptions
     // To add additional option, add property into the testOptMetadataNames, refer the property in either globalMetadataNames or fileMetadataNames
     // Add cases into convertGlobalOptionsToCompilationsSettings function for the compiler to acknowledge such option from meta data
-    let metadataOptionNames = {
+    const metadataOptionNames = {
         baselineFile: "BaselineFile",
         emitThisFile: "emitThisFile",  // This flag is used for testing getEmitOutput feature. It allows test-cases to indicate what file to be output in multiple files project
         fileName: "Filename",
@@ -126,10 +126,10 @@ namespace FourSlash {
     };
 
     // List of allowed metadata names
-    let fileMetadataNames = [metadataOptionNames.fileName, metadataOptionNames.emitThisFile, metadataOptionNames.resolveReference];
+    const fileMetadataNames = [metadataOptionNames.fileName, metadataOptionNames.emitThisFile, metadataOptionNames.resolveReference];
 
     function convertGlobalOptionsToCompilerOptions(globalOptions: Harness.TestCaseParser.CompilerSettings): ts.CompilerOptions {
-        let settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5 };
+        const settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5 };
         Harness.Compiler.setCompilerOptionsFromHarnessSetting(globalOptions, settings);
         return settings;
     }
@@ -224,7 +224,7 @@ namespace FourSlash {
         // Add input file which has matched file name with the given reference-file path.
         // This is necessary when resolveReference flag is specified
         private addMatchedInputFile(referenceFilePath: string) {
-            let inputFile = this.inputFiles[referenceFilePath];
+            const inputFile = this.inputFiles[referenceFilePath];
             if (inputFile && !Harness.isLibraryFile(referenceFilePath)) {
                 this.languageServiceAdapterHost.addScript(referenceFilePath, inputFile);
             }
@@ -248,8 +248,8 @@ namespace FourSlash {
         constructor(private basePath: string, private testType: FourSlashTestType, public testData: FourSlashData) {
             // Create a new Services Adapter
             this.cancellationToken = new TestCancellationToken();
-            let compilationOptions = convertGlobalOptionsToCompilerOptions(this.testData.globalOptions);
-            let languageServiceAdapter = this.getLanguageServiceAdapter(testType, this.cancellationToken, compilationOptions);
+            const compilationOptions = convertGlobalOptionsToCompilerOptions(this.testData.globalOptions);
+            const languageServiceAdapter = this.getLanguageServiceAdapter(testType, this.cancellationToken, compilationOptions);
             this.languageServiceAdapterHost = languageServiceAdapter.getHost();
             this.languageService = languageServiceAdapter.getLanguageService();
 
@@ -272,14 +272,14 @@ namespace FourSlash {
                 // Add the entry-point file itself into the languageServiceShimHost
                 this.languageServiceAdapterHost.addScript(startResolveFileRef.fileName, startResolveFileRef.content);
 
-                let resolvedResult = languageServiceAdapter.getPreProcessedFileInfo(startResolveFileRef.fileName, startResolveFileRef.content);
-                let referencedFiles: ts.FileReference[] = resolvedResult.referencedFiles;
-                let importedFiles: ts.FileReference[] = resolvedResult.importedFiles;
+                const resolvedResult = languageServiceAdapter.getPreProcessedFileInfo(startResolveFileRef.fileName, startResolveFileRef.content);
+                const referencedFiles: ts.FileReference[] = resolvedResult.referencedFiles;
+                const importedFiles: ts.FileReference[] = resolvedResult.importedFiles;
 
                 // Add triple reference files into language-service host
                 ts.forEach(referencedFiles, referenceFile => {
                     // Fourslash insert tests/cases/fourslash into inputFile.unitName so we will properly append the same base directory to refFile path
-                    let referenceFilePath = this.basePath + "/" + referenceFile.fileName;
+                    const referenceFilePath = this.basePath + "/" + referenceFile.fileName;
                     this.addMatchedInputFile(referenceFilePath);
                 });
 
@@ -287,7 +287,7 @@ namespace FourSlash {
                 ts.forEach(importedFiles, importedFile => {
                     // Fourslash insert tests/cases/fourslash into inputFile.unitName and import statement doesn't require ".ts"
                     // so convert them before making appropriate comparison
-                    let importedFilePath = this.basePath + "/" + importedFile.fileName + ".ts";
+                    const importedFilePath = this.basePath + "/" + importedFile.fileName + ".ts";
                     this.addMatchedInputFile(importedFilePath);
                 });
 
@@ -324,8 +324,8 @@ namespace FourSlash {
             };
 
             this.testData.files.forEach(file => {
-                let fileName = file.fileName.replace(Harness.IO.directoryName(file.fileName), "").substr(1);
-                let fileNameWithoutExtension = fileName.substr(0, fileName.lastIndexOf("."));
+                const fileName = file.fileName.replace(Harness.IO.directoryName(file.fileName), "").substr(1);
+                const fileNameWithoutExtension = fileName.substr(0, fileName.lastIndexOf("."));
                 this.scenarioActions.push("<CreateFileOnDisk FileId=\"" + fileName + "\" FileNameWithoutExtension=\"" + fileNameWithoutExtension + "\" FileExtension=\".ts\"><![CDATA[" + file.content + "]]></CreateFileOnDisk>");
             });
 
@@ -334,18 +334,18 @@ namespace FourSlash {
         }
 
         private getFileContent(fileName: string): string {
-            let script = this.languageServiceAdapterHost.getScriptInfo(fileName);
+            const script = this.languageServiceAdapterHost.getScriptInfo(fileName);
             return script.content;
         }
 
         // Entry points from fourslash.ts
         public goToMarker(name = "") {
-            let marker = this.getMarkerByName(name);
+            const marker = this.getMarkerByName(name);
             if (this.activeFile.fileName !== marker.fileName) {
                 this.openFile(marker.fileName);
             }
 
-            let content = this.getFileContent(marker.fileName);
+            const content = this.getFileContent(marker.fileName);
             if (marker.position === -1 || marker.position > content.length) {
                 throw new Error(`Marker "${name}" has been invalidated by unrecoverable edits to the file.`);
             }
@@ -356,8 +356,8 @@ namespace FourSlash {
         public goToPosition(pos: number) {
             this.currentCaretPosition = pos;
 
-            let lineStarts = ts.computeLineStarts(this.getFileContent(this.activeFile.fileName));
-            let lineCharPos = ts.computeLineAndCharacterOfPosition(lineStarts, pos);
+            const lineStarts = ts.computeLineStarts(this.getFileContent(this.activeFile.fileName));
+            const lineCharPos = ts.computeLineAndCharacterOfPosition(lineStarts, pos);
             this.scenarioActions.push(`<MoveCaretToLineAndChar LineNumber=${ lineCharPos.line + 1 } CharNumber=${ lineCharPos.character + 1 } />`);
         }
 
@@ -376,10 +376,10 @@ namespace FourSlash {
         public openFile(index: number): void;
         public openFile(name: string): void;
         public openFile(indexOrName: any) {
-            let fileToOpen: FourSlashFile = this.findFile(indexOrName);
+            const fileToOpen: FourSlashFile = this.findFile(indexOrName);
             fileToOpen.fileName = ts.normalizeSlashes(fileToOpen.fileName);
             this.activeFile = fileToOpen;
-            let fileName = fileToOpen.fileName.replace(Harness.IO.directoryName(fileToOpen.fileName), "").substr(1);
+            const fileName = fileToOpen.fileName.replace(Harness.IO.directoryName(fileToOpen.fileName), "").substr(1);
             this.scenarioActions.push(`<OpenFile FileName="" SrcFileId="${fileName}" FileId="${fileName}" />`);
 
             // Let the host know that this file is now open
@@ -387,13 +387,13 @@ namespace FourSlash {
         }
 
         public verifyErrorExistsBetweenMarkers(startMarkerName: string, endMarkerName: string, negative: boolean) {
-            let startMarker = this.getMarkerByName(startMarkerName);
-            let endMarker = this.getMarkerByName(endMarkerName);
-            let predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
+            const startMarker = this.getMarkerByName(startMarkerName);
+            const endMarker = this.getMarkerByName(endMarkerName);
+            const predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
                 return ((errorMinChar === startPos) && (errorLimChar === endPos)) ? true : false;
             };
 
-            let exists = this.anyErrorInRange(predicate, startMarker, endMarker);
+            const exists = this.anyErrorInRange(predicate, startMarker, endMarker);
 
             this.taoInvalidReason = "verifyErrorExistsBetweenMarkers NYI";
 
@@ -413,10 +413,10 @@ namespace FourSlash {
         }
 
         private getDiagnostics(fileName: string): ts.Diagnostic[] {
-            let syntacticErrors = this.languageService.getSyntacticDiagnostics(fileName);
-            let semanticErrors = this.languageService.getSemanticDiagnostics(fileName);
+            const syntacticErrors = this.languageService.getSyntacticDiagnostics(fileName);
+            const semanticErrors = this.languageService.getSemanticDiagnostics(fileName);
 
-            let diagnostics: ts.Diagnostic[] = [];
+            const diagnostics: ts.Diagnostic[] = [];
             diagnostics.push.apply(diagnostics, syntacticErrors);
             diagnostics.push.apply(diagnostics, semanticErrors);
 
@@ -424,9 +424,9 @@ namespace FourSlash {
         }
 
         private getAllDiagnostics(): ts.Diagnostic[] {
-            let diagnostics: ts.Diagnostic[] = [];
+            const diagnostics: ts.Diagnostic[] = [];
 
-            let fileNames = this.languageServiceAdapterHost.getFilenames();
+            const fileNames = this.languageServiceAdapterHost.getFilenames();
             for (let i = 0, n = fileNames.length; i < n; i++) {
                 diagnostics.push.apply(this.getDiagnostics(fileNames[i]));
             }
@@ -435,7 +435,7 @@ namespace FourSlash {
         }
 
         public verifyErrorExistsAfterMarker(markerName: string, negative: boolean, after: boolean) {
-            let marker: Marker = this.getMarkerByName(markerName);
+            const marker: Marker = this.getMarkerByName(markerName);
             let predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) => boolean;
 
             if (after) {
@@ -451,8 +451,8 @@ namespace FourSlash {
 
             this.taoInvalidReason = "verifyErrorExistsAfterMarker NYI";
 
-            let exists = this.anyErrorInRange(predicate, marker);
-            let diagnostics = this.getAllDiagnostics();
+            const exists = this.anyErrorInRange(predicate, marker);
+            const diagnostics = this.getAllDiagnostics();
 
             if (exists !== negative) {
                 this.printErrorLog(negative, diagnostics);
@@ -462,10 +462,10 @@ namespace FourSlash {
 
         private anyErrorInRange(predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) => boolean, startMarker: Marker, endMarker?: Marker) {
 
-            let errors = this.getDiagnostics(startMarker.fileName);
+            const errors = this.getDiagnostics(startMarker.fileName);
             let exists = false;
 
-            let startPos = startMarker.position;
+            const startPos = startMarker.position;
             let endPos: number = undefined;
             if (endMarker !== undefined) {
                 endPos = endMarker.position;
@@ -496,47 +496,47 @@ namespace FourSlash {
         }
 
         public verifyNumberOfErrorsInCurrentFile(expected: number) {
-            let errors = this.getDiagnostics(this.activeFile.fileName);
-            let actual = errors.length;
+            const errors = this.getDiagnostics(this.activeFile.fileName);
+            const actual = errors.length;
 
             this.scenarioActions.push(`<CheckErrorList ExpectedNumOfErrors="${expected}" />`);
 
             if (actual !== expected) {
                 this.printErrorLog(false, errors);
-                let errorMsg = "Actual number of errors (" + actual + ") does not match expected number (" + expected + ")";
+                const errorMsg = "Actual number of errors (" + actual + ") does not match expected number (" + expected + ")";
                 Harness.IO.log(errorMsg);
                 this.raiseError(errorMsg);
             }
         }
 
         public verifyEval(expr: string, value: any) {
-            let emit = this.languageService.getEmitOutput(this.activeFile.fileName);
+            const emit = this.languageService.getEmitOutput(this.activeFile.fileName);
             if (emit.outputFiles.length !== 1) {
                 throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);
             }
 
             this.taoInvalidReason = "verifyEval impossible";
 
-            let evaluation = new Function(`${emit.outputFiles[0].text};\r\nreturn (${expr});`)();
+            const evaluation = new Function(`${emit.outputFiles[0].text};\r\nreturn (${expr});`)();
             if (evaluation !== value) {
                 this.raiseError(`Expected evaluation of expression "${expr}" to equal "${value}", but got "${evaluation}"`);
             }
         }
 
         public verifyGetEmitOutputForCurrentFile(expected: string): void {
-            let emit = this.languageService.getEmitOutput(this.activeFile.fileName);
+            const emit = this.languageService.getEmitOutput(this.activeFile.fileName);
             if (emit.outputFiles.length !== 1) {
                 throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);
             }
             this.taoInvalidReason = "verifyGetEmitOutputForCurrentFile impossible";
-            let actual = emit.outputFiles[0].text;
+            const actual = emit.outputFiles[0].text;
             if (actual !== expected) {
                 this.raiseError(`Expected emit output to be "${expected}", but got "${actual}"`);
             }
         }
 
         public verifyGetEmitOutputContentsForCurrentFile(expected: { fileName: string; content: string; }[]): void {
-            let emit = this.languageService.getEmitOutput(this.activeFile.fileName);
+            const emit = this.languageService.getEmitOutput(this.activeFile.fileName);
             this.taoInvalidReason = "verifyGetEmitOutputContentsForCurrentFile impossible";
             assert.equal(emit.outputFiles.length, expected.length, "Number of emit output files");
             for (let i = 0; i < emit.outputFiles.length; i++) {
@@ -553,7 +553,7 @@ namespace FourSlash {
                 this.taoInvalidReason = "verifyMemberListContains only supports the \"symbol\" parameter";
             }
 
-            let members = this.getMemberListAtCaret();
+            const members = this.getMemberListAtCaret();
             if (members) {
                 this.assertItemInCompletionList(members.entries, symbol, text, documentation, kind);
             }
@@ -577,10 +577,10 @@ namespace FourSlash {
                 this.scenarioActions.push(`<VerifyCompletionItemsCount Count="${expectedCount}" ${(negative ? "ExpectsFailure=\"true\" " : "")}/>`);
             }
 
-            let members = this.getMemberListAtCaret();
+            const members = this.getMemberListAtCaret();
 
             if (members) {
-                let match = members.entries.length === expectedCount;
+                const match = members.entries.length === expectedCount;
 
                 if ((!match && !negative) || (match && negative)) {
                     this.raiseError("Member list count was " + members.entries.length + ". Expected " + expectedCount);
@@ -595,7 +595,7 @@ namespace FourSlash {
             this.scenarioActions.push("<ShowCompletionList />");
             this.scenarioActions.push(`<VerifyCompletionDoesNotContainItem ItemName="${escapeXmlAttributeValue(symbol)}" />`);
 
-            let members = this.getMemberListAtCaret();
+            const members = this.getMemberListAtCaret();
             if (members && members.entries.filter(e => e.name === symbol).length !== 0) {
                 this.raiseError(`Member list did contain ${symbol}`);
             }
@@ -604,8 +604,8 @@ namespace FourSlash {
         public verifyCompletionListItemsCountIsGreaterThan(count: number, negative: boolean) {
             this.taoInvalidReason = "verifyCompletionListItemsCountIsGreaterThan NYI";
 
-            let completions = this.getCompletionListAtCaret();
-            let itemsCount = completions.entries.length;
+            const completions = this.getCompletionListAtCaret();
+            const itemsCount = completions.entries.length;
 
             if (negative) {
                 if (itemsCount > count) {
@@ -627,7 +627,7 @@ namespace FourSlash {
                 this.scenarioActions.push("<ShowCompletionList ExpectsFailure=\"true\" />");
             }
 
-            let members = this.getMemberListAtCaret();
+            const members = this.getMemberListAtCaret();
             if ((!members || members.entries.length === 0) && negative) {
                 this.raiseError("Member list is empty at Caret");
             }
@@ -647,7 +647,7 @@ namespace FourSlash {
         public verifyCompletionListIsEmpty(negative: boolean) {
             this.scenarioActions.push("<ShowCompletionList ExpectsFailure=\"true\" />");
 
-            let completions = this.getCompletionListAtCaret();
+            const completions = this.getCompletionListAtCaret();
             if ((!completions || completions.entries.length === 0) && negative) {
                 this.raiseError("Completion list is empty at caret at position " + this.activeFile.fileName + " " + this.currentCaretPosition);
             }
@@ -664,7 +664,7 @@ namespace FourSlash {
 
 
         public verifyCompletionListAllowsNewIdentifier(negative: boolean) {
-            let completions = this.getCompletionListAtCaret();
+            const completions = this.getCompletionListAtCaret();
 
             if ((completions && !completions.isNewIdentifierLocation) && !negative) {
                 this.raiseError("Expected builder completion entry");
@@ -675,7 +675,7 @@ namespace FourSlash {
         }
 
         public verifyCompletionListContains(symbol: string, text?: string, documentation?: string, kind?: string) {
-            let completions = this.getCompletionListAtCaret();
+            const completions = this.getCompletionListAtCaret();
             if (completions) {
                 this.assertItemInCompletionList(completions.entries, symbol, text, documentation, kind);
             }
@@ -695,11 +695,11 @@ namespace FourSlash {
          * @param expectedKind the kind of symbol (see ScriptElementKind)
          */
         public verifyCompletionListDoesNotContain(symbol: string, expectedText?: string, expectedDocumentation?: string, expectedKind?: string) {
-            let that = this;
+            const that = this;
             function filterByTextOrDocumentation(entry: ts.CompletionEntry) {
-                let details = that.getCompletionEntryDetails(entry.name);
-                let documentation = ts.displayPartsToString(details.documentation);
-                let text = ts.displayPartsToString(details.displayParts);
+                const details = that.getCompletionEntryDetails(entry.name);
+                const documentation = ts.displayPartsToString(details.documentation);
+                const text = ts.displayPartsToString(details.displayParts);
                 if (expectedText && expectedDocumentation) {
                     return (documentation === expectedDocumentation && text === expectedText) ? true : false;
                 }
@@ -717,7 +717,7 @@ namespace FourSlash {
             this.scenarioActions.push("<ShowCompletionList />");
             this.scenarioActions.push(`<VerifyCompletionDoesNotContainItem ItemName="${escapeXmlAttributeValue(symbol)}" />`);
 
-            let completions = this.getCompletionListAtCaret();
+            const completions = this.getCompletionListAtCaret();
             if (completions) {
                 let filterCompletions = completions.entries.filter(e => e.name === symbol);
                 filterCompletions = expectedKind ? filterCompletions.filter(e => e.kind === expectedKind) : filterCompletions;
@@ -727,7 +727,7 @@ namespace FourSlash {
                     // then these symbols must meet the criterion for Not supposed to be in the list. So we
                     // raise an error
                     let error = "Completion list did contain \'" + symbol + "\'.";
-                    let details = this.getCompletionEntryDetails(filterCompletions[0].name);
+                    const details = this.getCompletionEntryDetails(filterCompletions[0].name);
                     if (expectedText) {
                         error += "Expected text: " + expectedText + " to equal: " + ts.displayPartsToString(details.displayParts) + ".";
                     }
@@ -745,7 +745,7 @@ namespace FourSlash {
         public verifyCompletionEntryDetails(entryName: string, expectedText: string, expectedDocumentation?: string, kind?: string) {
             this.taoInvalidReason = "verifyCompletionEntryDetails NYI";
 
-            let details = this.getCompletionEntryDetails(entryName);
+            const details = this.getCompletionEntryDetails(entryName);
 
             assert.equal(ts.displayPartsToString(details.displayParts), expectedText, assertionMessage("completion entry details text"));
 
@@ -761,14 +761,14 @@ namespace FourSlash {
         public verifyReferencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean) {
             this.taoInvalidReason = "verifyReferencesAtPositionListContains NYI";
 
-            let references = this.getReferencesAtCaret();
+            const references = this.getReferencesAtCaret();
 
             if (!references || references.length === 0) {
                 this.raiseError("verifyReferencesAtPositionListContains failed - found 0 references, expected at least one.");
             }
 
             for (let i = 0; i < references.length; i++) {
-                let reference = references[i];
+                const reference = references[i];
                 if (reference && reference.fileName === fileName && reference.textSpan.start === start && ts.textSpanEnd(reference.textSpan) === end) {
                     if (typeof isWriteAccess !== "undefined" && reference.isWriteAccess !== isWriteAccess) {
                         this.raiseError(`verifyReferencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ${reference.isWriteAccess}, expected: ${isWriteAccess}.`);
@@ -777,18 +777,18 @@ namespace FourSlash {
                 }
             }
 
-            let missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };
+            const missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };
             this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${JSON.stringify(missingItem)} in the returned list: (${JSON.stringify(references)})`);
         }
 
         public verifyReferencesCountIs(count: number, localFilesOnly = true) {
             this.taoInvalidReason = "verifyReferences NYI";
 
-            let references = this.getReferencesAtCaret();
+            const references = this.getReferencesAtCaret();
             let referencesCount = 0;
 
             if (localFilesOnly) {
-                let localFiles = this.testData.files.map<string>(file => file.fileName);
+                const localFiles = this.testData.files.map<string>(file => file.fileName);
                 // Count only the references in local files. Filter the ones in lib and other files.
                 ts.forEach(references, entry => {
                     if (localFiles.some((fileName) => fileName === entry.fileName)) {
@@ -801,7 +801,7 @@ namespace FourSlash {
             }
 
             if (referencesCount !== count) {
-                let condition = localFilesOnly ? "excluding libs" : "including libs";
+                const condition = localFilesOnly ? "excluding libs" : "including libs";
                 this.raiseError("Expected references count (" + condition + ") to be " + count + ", but is actually " + referencesCount);
             }
         }
@@ -827,18 +827,18 @@ namespace FourSlash {
         }
 
         public getSyntacticDiagnostics(expected: string) {
-            let diagnostics = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
+            const diagnostics = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
             this.testDiagnostics(expected, diagnostics);
         }
 
         public getSemanticDiagnostics(expected: string) {
-            let diagnostics = this.languageService.getSemanticDiagnostics(this.activeFile.fileName);
+            const diagnostics = this.languageService.getSemanticDiagnostics(this.activeFile.fileName);
             this.testDiagnostics(expected, diagnostics);
         }
 
         private testDiagnostics(expected: string, diagnostics: ts.Diagnostic[]) {
-            let realized = ts.realizeDiagnostics(diagnostics, "\r\n");
-            let actual = JSON.stringify(realized, null, "  ");
+            const realized = ts.realizeDiagnostics(diagnostics, "\r\n");
+            const actual = JSON.stringify(realized, null, "  ");
             assert.equal(actual, expected);
         }
 
@@ -850,9 +850,9 @@ namespace FourSlash {
                 }
             });
 
-            let actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            let actualQuickInfoText = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.displayParts) : "";
-            let actualQuickInfoDocumentation = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.documentation) : "";
+            const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actualQuickInfoText = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.displayParts) : "";
+            const actualQuickInfoDocumentation = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.documentation) : "";
 
             if (negative) {
                 if (expectedText !== undefined) {
@@ -898,7 +898,7 @@ namespace FourSlash {
                 return result;
             }
 
-            let actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             assert.equal(actualQuickInfo.kind, kind, this.messageAtLastKnownMarker("QuickInfo kind"));
             assert.equal(actualQuickInfo.kindModifiers, kindModifiers, this.messageAtLastKnownMarker("QuickInfo kindModifiers"));
             assert.equal(JSON.stringify(actualQuickInfo.textSpan), JSON.stringify(textSpan), this.messageAtLastKnownMarker("QuickInfo textSpan"));
@@ -907,7 +907,7 @@ namespace FourSlash {
         }
 
         public verifyRenameLocations(findInStrings: boolean, findInComments: boolean) {
-            let renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
+            const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
             if (renameInfo.canRename) {
                 let references = this.languageService.findRenameLocations(
                     this.activeFile.fileName, this.currentCaretPosition, findInStrings, findInComments);
@@ -929,8 +929,8 @@ namespace FourSlash {
                 references = references.sort((r1, r2) => r1.textSpan.start - r2.textSpan.start);
 
                 for (let i = 0, n = ranges.length; i < n; i++) {
-                    let reference = references[i];
-                    let range = ranges[i];
+                    const reference = references[i];
+                    const range = ranges[i];
 
                     if (reference.textSpan.start !== range.start ||
                         ts.textSpanEnd(reference.textSpan) !== range.end) {
@@ -947,7 +947,7 @@ namespace FourSlash {
         public verifyQuickInfoExists(negative: boolean) {
             this.taoInvalidReason = "verifyQuickInfoExists NYI";
 
-            let actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             if (negative) {
                 if (actualQuickInfo) {
                     this.raiseError("verifyQuickInfoExists failed. Expected quick info NOT to exist");
@@ -963,7 +963,7 @@ namespace FourSlash {
         public verifyCurrentSignatureHelpIs(expected: string) {
             this.taoInvalidReason = "verifyCurrentSignatureHelpIs NYI";
 
-            let help = this.getActiveSignatureHelpItem();
+            const help = this.getActiveSignatureHelpItem();
             assert.equal(
                 ts.displayPartsToString(help.prefixDisplayParts) +
                 help.parameters.map(p => ts.displayPartsToString(p.displayParts)).join(ts.displayPartsToString(help.separatorDisplayParts)) +
@@ -973,7 +973,7 @@ namespace FourSlash {
         public verifyCurrentParameterIsletiable(isVariable: boolean) {
             this.taoInvalidReason = "verifyCurrentParameterIsletiable NYI";
 
-            let signature = this.getActiveSignatureHelpItem();
+            const signature = this.getActiveSignatureHelpItem();
             assert.isNotNull(signature);
             assert.equal(isVariable, signature.isVariadic);
         }
@@ -981,24 +981,24 @@ namespace FourSlash {
         public verifyCurrentParameterHelpName(name: string) {
             this.taoInvalidReason = "verifyCurrentParameterHelpName NYI";
 
-            let activeParameter = this.getActiveParameter();
-            let activeParameterName = activeParameter.name;
+            const activeParameter = this.getActiveParameter();
+            const activeParameterName = activeParameter.name;
             assert.equal(activeParameterName, name);
         }
 
         public verifyCurrentParameterSpanIs(parameter: string) {
             this.taoInvalidReason = "verifyCurrentParameterSpanIs NYI";
 
-            let activeSignature = this.getActiveSignatureHelpItem();
-            let activeParameter = this.getActiveParameter();
+            const activeSignature = this.getActiveSignatureHelpItem();
+            const activeParameter = this.getActiveParameter();
             assert.equal(ts.displayPartsToString(activeParameter.displayParts), parameter);
         }
 
         public verifyCurrentParameterHelpDocComment(docComment: string) {
             this.taoInvalidReason = "verifyCurrentParameterHelpDocComment NYI";
 
-            let activeParameter = this.getActiveParameter();
-            let activeParameterDocComment = activeParameter.documentation;
+            const activeParameter = this.getActiveParameter();
+            const activeParameterDocComment = activeParameter.documentation;
             assert.equal(ts.displayPartsToString(activeParameterDocComment), docComment, assertionMessage("current parameter Help DocComment"));
         }
 
@@ -1017,7 +1017,7 @@ namespace FourSlash {
         public verifyCurrentSignatureHelpDocComment(docComment: string) {
             this.taoInvalidReason = "verifyCurrentSignatureHelpDocComment NYI";
 
-            let actualDocComment = this.getActiveSignatureHelpItem().documentation;
+            const actualDocComment = this.getActiveSignatureHelpItem().documentation;
             assert.equal(ts.displayPartsToString(actualDocComment), docComment, assertionMessage("current signature help doc comment"));
         }
 
@@ -1025,22 +1025,22 @@ namespace FourSlash {
             this.scenarioActions.push("<InvokeSignatureHelp />");
             this.scenarioActions.push(`<VerifySignatureHelpOverloadCountEquals Count="${expected}" />`);
 
-            let help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
-            let actual = help && help.items ? help.items.length : 0;
+            const help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
+            const actual = help && help.items ? help.items.length : 0;
             assert.equal(actual, expected);
         }
 
         public verifySignatureHelpArgumentCount(expected: number) {
             this.taoInvalidReason = "verifySignatureHelpArgumentCount NYI";
-            let signatureHelpItems = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
-            let actual = signatureHelpItems.argumentCount;
+            const signatureHelpItems = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
+            const actual = signatureHelpItems.argumentCount;
             assert.equal(actual, expected);
         }
 
         public verifySignatureHelpPresent(shouldBePresent = true) {
             this.taoInvalidReason = "verifySignatureHelpPresent NYI";
 
-            let actual = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
+            const actual = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
             if (shouldBePresent) {
                 if (!actual) {
                     this.raiseError("Expected signature help to be present, but it wasn't");
@@ -1060,7 +1060,7 @@ namespace FourSlash {
         }
 
         public verifyRenameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string) {
-            let renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
+            const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
             if (!renameInfo.canRename) {
                 this.raiseError("Rename did not succeed");
             }
@@ -1074,7 +1074,7 @@ namespace FourSlash {
                 this.raiseError("Expected a single range to be selected in the test file.");
             }
 
-            let expectedRange = this.getRanges()[0];
+            const expectedRange = this.getRanges()[0];
             if (renameInfo.triggerSpan.start !== expectedRange.start ||
                 ts.textSpanEnd(renameInfo.triggerSpan) !== expectedRange.end) {
                 this.raiseError("Expected triggerSpan [" + expectedRange.start + "," + expectedRange.end + ").  Got [" +
@@ -1083,7 +1083,7 @@ namespace FourSlash {
         }
 
         public verifyRenameInfoFailed(message?: string) {
-            let renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
+            const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);
             if (renameInfo.canRename) {
                 this.raiseError("Rename was expected to fail");
             }
@@ -1092,15 +1092,15 @@ namespace FourSlash {
         }
 
         private getActiveSignatureHelpItem() {
-            let help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
-            let index = help.selectedItemIndex;
+            const help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
+            const index = help.selectedItemIndex;
             return help.items[index];
         }
 
         private getActiveParameter(): ts.SignatureHelpParameter {
-            let help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
-            let item = help.items[help.selectedItemIndex];
-            let currentParam = help.argumentIndex;
+            const help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
+            const item = help.items[help.selectedItemIndex];
+            const currentParam = help.argumentIndex;
             return item.parameters[currentParam];
         }
 
@@ -1109,8 +1109,8 @@ namespace FourSlash {
         private spanInfoToString(pos: number, spanInfo: ts.TextSpan, prefixString: string) {
             let resultString = "SpanInfo: " + JSON.stringify(spanInfo);
             if (spanInfo) {
-                let spanString = this.activeFile.content.substr(spanInfo.start, spanInfo.length);
-                let spanLineMap = ts.computeLineStarts(spanString);
+                const spanString = this.activeFile.content.substr(spanInfo.start, spanInfo.length);
+                const spanLineMap = ts.computeLineStarts(spanString);
                 for (let i = 0; i < spanLineMap.length; i++) {
                     if (!i) {
                         resultString += "\n";
@@ -1124,17 +1124,17 @@ namespace FourSlash {
         }
 
         private baselineCurrentFileLocations(getSpanAtPos: (pos: number) => ts.TextSpan): string {
-            let fileLineMap = ts.computeLineStarts(this.activeFile.content);
+            const fileLineMap = ts.computeLineStarts(this.activeFile.content);
             let nextLine = 0;
             let resultString = "";
             let currentLine: string;
             let previousSpanInfo: string;
             let startColumn: number;
             let length: number;
-            let prefixString = "    >";
+            const prefixString = "    >";
 
             let pos = 0;
-            let addSpanInfoString = () => {
+            const addSpanInfoString = () => {
                 if (previousSpanInfo) {
                     resultString += currentLine;
                     let thisLineMarker = repeatString(startColumn, " ") + repeatString(length, "~");
@@ -1157,7 +1157,7 @@ namespace FourSlash {
                     startColumn = 0;
                     length = 0;
                 }
-                let spanInfo = this.spanInfoToString(pos, getSpanAtPos(pos), prefixString);
+                const spanInfo = this.spanInfoToString(pos, getSpanAtPos(pos), prefixString);
                 if (previousSpanInfo && previousSpanInfo !== spanInfo) {
                     addSpanInfoString();
                     previousSpanInfo = spanInfo;
@@ -1201,11 +1201,11 @@ namespace FourSlash {
         public baselineGetEmitOutput() {
             this.taoInvalidReason = "baselineGetEmitOutput impossible";
             // Find file to be emitted
-            let emitFiles: FourSlashFile[] = [];  // List of FourSlashFile that has emitThisFile flag on
+            const emitFiles: FourSlashFile[] = [];  // List of FourSlashFile that has emitThisFile flag on
 
-            let allFourSlashFiles = this.testData.files;
+            const allFourSlashFiles = this.testData.files;
             for (let idx = 0; idx < allFourSlashFiles.length; ++idx) {
-                let file = allFourSlashFiles[idx];
+                const file = allFourSlashFiles[idx];
                 if (file.fileOptions[metadataOptionNames.emitThisFile] === "true") {
                     // Find a file with the flag emitThisFile turned on
                     emitFiles.push(file);
@@ -1224,20 +1224,20 @@ namespace FourSlash {
                     let resultString = "";
                     // Loop through all the emittedFiles and emit them one by one
                     emitFiles.forEach(emitFile => {
-                        let emitOutput = this.languageService.getEmitOutput(emitFile.fileName);
+                        const emitOutput = this.languageService.getEmitOutput(emitFile.fileName);
                         // Print emitOutputStatus in readable format
                         resultString += "EmitSkipped: " + emitOutput.emitSkipped + Harness.IO.newLine();
 
                         if (emitOutput.emitSkipped) {
                             resultString += "Diagnostics:" + Harness.IO.newLine();
-                            let diagnostics = ts.getPreEmitDiagnostics(this.languageService.getProgram());
+                            const diagnostics = ts.getPreEmitDiagnostics(this.languageService.getProgram());
                             for (let i = 0, n = diagnostics.length; i < n; i++) {
                                 resultString += "  " + diagnostics[0].messageText + Harness.IO.newLine();
                             }
                         }
 
                         emitOutput.outputFiles.forEach((outputFile, idx, array) => {
-                            let fileName = "FileName : " + outputFile.name + Harness.IO.newLine();
+                            const fileName = "FileName : " + outputFile.name + Harness.IO.newLine();
                             resultString = resultString + fileName + outputFile.text;
                         });
                         resultString += Harness.IO.newLine();
@@ -1257,19 +1257,19 @@ namespace FourSlash {
         }
 
         public printCurrentParameterHelp() {
-            let help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
+            const help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);
             Harness.IO.log(JSON.stringify(help));
         }
 
         public printCurrentQuickInfo() {
-            let quickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const quickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             Harness.IO.log(JSON.stringify(quickInfo));
         }
 
         public printErrorList() {
-            let syntacticErrors = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
-            let semanticErrors = this.languageService.getSemanticDiagnostics(this.activeFile.fileName);
-            let errorList = syntacticErrors.concat(semanticErrors);
+            const syntacticErrors = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
+            const semanticErrors = this.languageService.getSemanticDiagnostics(this.activeFile.fileName);
+            const errorList = syntacticErrors.concat(semanticErrors);
             Harness.IO.log(`Error list (${errorList.length} errors)`);
 
             if (errorList.length) {
@@ -1284,8 +1284,8 @@ namespace FourSlash {
 
         public printCurrentFileState(makeWhitespaceVisible = false, makeCaretVisible = true) {
             for (let i = 0; i < this.testData.files.length; i++) {
-                let file = this.testData.files[i];
-                let active = (this.activeFile === file);
+                const file = this.testData.files[i];
+                const active = (this.activeFile === file);
                 Harness.IO.log(`=== Script (${file.fileName}) ${(active ? "(active, cursor at |)" : "")} ===`);
                 let content = this.getFileContent(file.fileName);
                 if (active) {
@@ -1299,22 +1299,22 @@ namespace FourSlash {
         }
 
         public printCurrentSignatureHelp() {
-            let sigHelp = this.getActiveSignatureHelpItem();
+            const sigHelp = this.getActiveSignatureHelpItem();
             Harness.IO.log(JSON.stringify(sigHelp));
         }
 
         public printMemberListMembers() {
-            let members = this.getMemberListAtCaret();
+            const members = this.getMemberListAtCaret();
             Harness.IO.log(JSON.stringify(members));
         }
 
         public printCompletionListMembers() {
-            let completions = this.getCompletionListAtCaret();
+            const completions = this.getCompletionListAtCaret();
             Harness.IO.log(JSON.stringify(completions));
         }
 
         public printReferences() {
-            let references = this.getReferencesAtCaret();
+            const references = this.getReferencesAtCaret();
             ts.forEach(references, entry => {
                 Harness.IO.log(JSON.stringify(entry));
             });
@@ -1328,9 +1328,9 @@ namespace FourSlash {
             this.scenarioActions.push(`<DeleteCharNext Count="${count}" />`);
 
             let offset = this.currentCaretPosition;
-            let ch = "";
+            const ch = "";
 
-            let checkCadence = (count >> 2) + 1;
+            const checkCadence = (count >> 2) + 1;
 
             for (let i = 0; i < count; i++) {
                 // Make the edit
@@ -1343,7 +1343,7 @@ namespace FourSlash {
 
                 // Handle post-keystroke formatting
                 if (this.enableFormatting) {
-                    let edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
+                    const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
                         offset += this.applyEdits(this.activeFile.fileName, edits, true);
                         // this.checkPostEditInletiants();
@@ -1370,8 +1370,8 @@ namespace FourSlash {
             this.scenarioActions.push(`<DeleteCharPrevious Count="${count}" />`);
 
             let offset = this.currentCaretPosition;
-            let ch = "";
-            let checkCadence = (count >> 2) + 1;
+            const ch = "";
+            const checkCadence = (count >> 2) + 1;
 
             for (let i = 0; i < count; i++) {
                 offset--;
@@ -1385,7 +1385,7 @@ namespace FourSlash {
 
                 // Handle post-keystroke formatting
                 if (this.enableFormatting) {
-                    let edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
+                    const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
                         offset += this.applyEdits(this.activeFile.fileName, edits, true);
                     }
@@ -1416,12 +1416,12 @@ namespace FourSlash {
         // as much as possible
         private typeHighFidelity(text: string) {
             let offset = this.currentCaretPosition;
-            let prevChar = " ";
-            let checkCadence = (text.length >> 2) + 1;
+            const prevChar = " ";
+            const checkCadence = (text.length >> 2) + 1;
 
             for (let i = 0; i < text.length; i++) {
                 // Make the edit
-                let ch = text.charAt(i);
+                const ch = text.charAt(i);
                 this.languageServiceAdapterHost.editScript(this.activeFile.fileName, offset, offset, ch);
                 this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, offset);
 
@@ -1445,7 +1445,7 @@ namespace FourSlash {
 
                 // Handle post-keystroke formatting
                 if (this.enableFormatting) {
-                    let edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
+                    const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
                         offset += this.applyEdits(this.activeFile.fileName, edits, true);
                         // this.checkPostEditInletiants();
@@ -1464,7 +1464,7 @@ namespace FourSlash {
         public paste(text: string) {
             this.scenarioActions.push(`<InsertText><![CDATA[${text}]]></InsertText>`);
 
-            let start = this.currentCaretPosition;
+            const start = this.currentCaretPosition;
             let offset = this.currentCaretPosition;
             this.languageServiceAdapterHost.editScript(this.activeFile.fileName, offset, offset, text);
             this.updateMarkersForEdit(this.activeFile.fileName, offset, offset, text);
@@ -1473,7 +1473,7 @@ namespace FourSlash {
 
             // Handle formatting
             if (this.enableFormatting) {
-                let edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, offset, this.formatCodeOptions);
+                const edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, offset, this.formatCodeOptions);
                 if (edits.length) {
                     offset += this.applyEdits(this.activeFile.fileName, edits, true);
                     this.checkPostEditInletiants();
@@ -1494,17 +1494,17 @@ namespace FourSlash {
                 return;
             }
 
-            let incrementalSourceFile = this.languageService.getSourceFile(this.activeFile.fileName);
+            const incrementalSourceFile = this.languageService.getSourceFile(this.activeFile.fileName);
             Utils.assertInvariants(incrementalSourceFile, /*parent:*/ undefined);
 
-            let incrementalSyntaxDiagnostics = incrementalSourceFile.parseDiagnostics;
+            const incrementalSyntaxDiagnostics = incrementalSourceFile.parseDiagnostics;
 
             // Check syntactic structure
-            let content = this.getFileContent(this.activeFile.fileName);
+            const content = this.getFileContent(this.activeFile.fileName);
 
-            let referenceSourceFile = ts.createLanguageServiceSourceFile(
+            const referenceSourceFile = ts.createLanguageServiceSourceFile(
                 this.activeFile.fileName, createScriptSnapShot(content), ts.ScriptTarget.Latest, /*version:*/ "0", /*setNodeParents:*/ false);
-            let referenceSyntaxDiagnostics = referenceSourceFile.parseDiagnostics;
+            const referenceSyntaxDiagnostics = referenceSourceFile.parseDiagnostics;
 
             Utils.assertDiagnosticsEquals(incrementalSyntaxDiagnostics, referenceSyntaxDiagnostics);
             Utils.assertStructuralEquals(incrementalSourceFile, referenceSourceFile);
@@ -1514,7 +1514,7 @@ namespace FourSlash {
             // The caret can potentially end up between the \r and \n, which is confusing. If
             // that happens, move it back one character
             if (this.currentCaretPosition > 0) {
-                let ch = this.getFileContent(this.activeFile.fileName).substring(this.currentCaretPosition - 1, this.currentCaretPosition);
+                const ch = this.getFileContent(this.activeFile.fileName).substring(this.currentCaretPosition - 1, this.currentCaretPosition);
                 if (ch === "\r") {
                     this.currentCaretPosition--;
                 }
@@ -1527,18 +1527,18 @@ namespace FourSlash {
             let runningOffset = 0;
             edits = edits.sort((a, b) => a.span.start - b.span.start);
             // Get a snapshot of the content of the file so we can make sure any formatting edits didn't destroy non-whitespace characters
-            let oldContent = this.getFileContent(this.activeFile.fileName);
+            const oldContent = this.getFileContent(this.activeFile.fileName);
             for (let j = 0; j < edits.length; j++) {
                 this.languageServiceAdapterHost.editScript(fileName, edits[j].span.start + runningOffset, ts.textSpanEnd(edits[j].span) + runningOffset, edits[j].newText);
                 this.updateMarkersForEdit(fileName, edits[j].span.start + runningOffset, ts.textSpanEnd(edits[j].span) + runningOffset, edits[j].newText);
-                let change = (edits[j].span.start - ts.textSpanEnd(edits[j].span)) + edits[j].newText.length;
+                const change = (edits[j].span.start - ts.textSpanEnd(edits[j].span)) + edits[j].newText.length;
                 runningOffset += change;
                 // TODO: Consider doing this at least some of the time for higher fidelity. Currently causes a failure (bug 707150)
                 // this.languageService.getScriptLexicalStructure(fileName);
             }
 
             if (isFormattingEdit) {
-                let newContent = this.getFileContent(fileName);
+                const newContent = this.getFileContent(fileName);
 
                 if (newContent.replace(/\s/g, "") !== oldContent.replace(/\s/g, "")) {
                     this.raiseError("Formatting operation destroyed non-whitespace content");
@@ -1552,7 +1552,7 @@ namespace FourSlash {
         }
 
         public setFormatOptions(formatCodeOptions: ts.FormatCodeOptions): ts.FormatCodeOptions {
-            let oldFormatCodeOptions = this.formatCodeOptions;
+            const oldFormatCodeOptions = this.formatCodeOptions;
             this.formatCodeOptions = formatCodeOptions;
             return oldFormatCodeOptions;
         }
@@ -1560,7 +1560,7 @@ namespace FourSlash {
         public formatDocument() {
             this.scenarioActions.push("<FormatDocument />");
 
-            let edits = this.languageService.getFormattingEditsForDocument(this.activeFile.fileName, this.formatCodeOptions);
+            const edits = this.languageService.getFormattingEditsForDocument(this.activeFile.fileName, this.formatCodeOptions);
             this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, true);
             this.fixCaretPosition();
         }
@@ -1568,14 +1568,14 @@ namespace FourSlash {
         public formatSelection(start: number, end: number) {
             this.taoInvalidReason = "formatSelection NYI";
 
-            let edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, end, this.formatCodeOptions);
+            const edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, end, this.formatCodeOptions);
             this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, true);
             this.fixCaretPosition();
         }
 
         private updateMarkersForEdit(fileName: string, minChar: number, limChar: number, text: string) {
             for (let i = 0; i < this.testData.markers.length; i++) {
-                let marker = this.testData.markers[i];
+                const marker = this.testData.markers[i];
                 if (marker.fileName === fileName) {
                     if (marker.position > minChar) {
                         if (marker.position < limChar) {
@@ -1596,7 +1596,7 @@ namespace FourSlash {
         }
 
         public goToEOF() {
-            let len = this.getFileContent(this.activeFile.fileName).length;
+            const len = this.getFileContent(this.activeFile.fileName).length;
             this.goToPosition(len);
         }
 
@@ -1608,7 +1608,7 @@ namespace FourSlash {
                 this.taoInvalidReason = "GoToDefinition not supported for non-zero definition indices";
             }
 
-            let definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             if (!definitions || !definitions.length) {
                 this.raiseError("goToDefinition failed - expected to at least one definition location but got 0");
             }
@@ -1617,7 +1617,7 @@ namespace FourSlash {
                 this.raiseError(`goToDefinition failed - definitionIndex value (${definitionIndex}) exceeds definition list size (${definitions.length})`);
             }
 
-            let definition = definitions[definitionIndex];
+            const definition = definitions[definitionIndex];
             this.openFile(definition.fileName);
             this.currentCaretPosition = definition.textSpan.start;
         }
@@ -1630,7 +1630,7 @@ namespace FourSlash {
                 this.taoInvalidReason = "GoToTypeDefinition not supported for non-zero definition indices";
             }
 
-            let definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             if (!definitions || !definitions.length) {
                 this.raiseError("goToTypeDefinition failed - expected to at least one definition location but got 0");
             }
@@ -1639,7 +1639,7 @@ namespace FourSlash {
                 this.raiseError(`goToTypeDefinition failed - definitionIndex value (${definitionIndex}) exceeds definition list size (${definitions.length})`);
             }
 
-            let definition = definitions[definitionIndex];
+            const definition = definitions[definitionIndex];
             this.openFile(definition.fileName);
             this.currentCaretPosition = definition.textSpan.start;
         }
@@ -1647,9 +1647,9 @@ namespace FourSlash {
         public verifyDefinitionLocationExists(negative: boolean) {
             this.taoInvalidReason = "verifyDefinitionLocationExists NYI";
 
-            let definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
 
-            let foundDefinitions = definitions && definitions.length;
+            const foundDefinitions = definitions && definitions.length;
 
             if (foundDefinitions && negative) {
                 this.raiseError(`goToDefinition - expected to 0 definition locations but got ${definitions.length}`);
@@ -1660,19 +1660,19 @@ namespace FourSlash {
         }
 
         public verifyDefinitionsCount(negative: boolean, expectedCount: number) {
-            let assertFn = negative ? assert.notEqual : assert.equal;
+            const assertFn = negative ? assert.notEqual : assert.equal;
 
-            let definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            let actualCount = definitions && definitions.length || 0;
+            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actualCount = definitions && definitions.length || 0;
 
             assertFn(actualCount, expectedCount, this.messageAtLastKnownMarker("Definitions Count"));
         }
 
         public verifyTypeDefinitionsCount(negative: boolean, expectedCount: number) {
-            let assertFn = negative ? assert.notEqual : assert.equal;
+            const assertFn = negative ? assert.notEqual : assert.equal;
 
-            let definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            let actualCount = definitions && definitions.length || 0;
+            const definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actualCount = definitions && definitions.length || 0;
 
             assertFn(actualCount, expectedCount, this.messageAtLastKnownMarker("Type definitions Count"));
         }
@@ -1680,9 +1680,9 @@ namespace FourSlash {
         public verifyDefinitionsName(negative: boolean, expectedName: string, expectedContainerName: string) {
             this.taoInvalidReason = "verifyDefinititionsInfo NYI";
 
-            let definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            let actualDefinitionName = definitions && definitions.length ? definitions[0].name : "";
-            let actualDefinitionContainerName = definitions && definitions.length ? definitions[0].containerName : "";
+            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actualDefinitionName = definitions && definitions.length ? definitions[0].name : "";
+            const actualDefinitionContainerName = definitions && definitions.length ? definitions[0].containerName : "";
             if (negative) {
                 assert.notEqual(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
                 assert.notEqual(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
@@ -1706,7 +1706,7 @@ namespace FourSlash {
         public verifyCaretAtMarker(markerName = "") {
             this.taoInvalidReason = "verifyCaretAtMarker NYI";
 
-            let pos = this.getMarkerByName(markerName);
+            const pos = this.getMarkerByName(markerName);
             if (pos.fileName !== this.activeFile.fileName) {
                 throw new Error(`verifyCaretAtMarker failed - expected to be in file "${pos.fileName}", but was in file "${this.activeFile.fileName}"`);
             }
@@ -1717,7 +1717,7 @@ namespace FourSlash {
 
         private getIndentation(fileName: string, position: number, indentStyle: ts.IndentStyle): number {
 
-            let formatOptions = ts.clone(this.formatCodeOptions);
+            const formatOptions = ts.clone(this.formatCodeOptions);
             formatOptions.IndentStyle = indentStyle;
 
             return this.languageService.getIndentationAtPosition(fileName, position, formatOptions);
@@ -1726,8 +1726,8 @@ namespace FourSlash {
         public verifyIndentationAtCurrentPosition(numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) {
             this.taoInvalidReason = "verifyIndentationAtCurrentPosition NYI";
 
-            let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition, indentStyle);
-            let lineCol = this.getLineColStringAtPosition(this.currentCaretPosition);
+            const actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition, indentStyle);
+            const lineCol = this.getLineColStringAtPosition(this.currentCaretPosition);
             if (actual !== numberOfSpaces) {
                 this.raiseError(`verifyIndentationAtCurrentPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`);
             }
@@ -1736,8 +1736,8 @@ namespace FourSlash {
         public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) {
             this.taoInvalidReason = "verifyIndentationAtPosition NYI";
 
-            let actual = this.getIndentation(fileName, position, indentStyle);
-            let lineCol = this.getLineColStringAtPosition(position);
+            const actual = this.getIndentation(fileName, position, indentStyle);
+            const lineCol = this.getLineColStringAtPosition(position);
             if (actual !== numberOfSpaces) {
                 this.raiseError(`verifyIndentationAtPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`);
             }
@@ -1746,7 +1746,7 @@ namespace FourSlash {
         public verifyCurrentLineContent(text: string) {
             this.taoInvalidReason = "verifyCurrentLineContent NYI";
 
-            let actual = this.getCurrentLineContent();
+            const actual = this.getCurrentLineContent();
             if (actual !== text) {
                 throw new Error("verifyCurrentLineContent\n" +
                     "\tExpected: \"" + text + "\"\n" +
@@ -1757,8 +1757,8 @@ namespace FourSlash {
         public verifyCurrentFileContent(text: string) {
             this.taoInvalidReason = "verifyCurrentFileContent NYI";
 
-            let actual = this.getFileContent(this.activeFile.fileName);
-            let replaceNewlines = (str: string) => str.replace(/\r\n/g, "\n");
+            const actual = this.getFileContent(this.activeFile.fileName);
+            const replaceNewlines = (str: string) => str.replace(/\r\n/g, "\n");
             if (replaceNewlines(actual) !== replaceNewlines(text)) {
                 throw new Error("verifyCurrentFileContent\n" +
                     "\tExpected: \"" + text + "\"\n" +
@@ -1769,7 +1769,7 @@ namespace FourSlash {
         public verifyTextAtCaretIs(text: string) {
             this.taoInvalidReason = "verifyCurrentFileContent NYI";
 
-            let actual = this.getFileContent(this.activeFile.fileName).substring(this.currentCaretPosition, this.currentCaretPosition + text.length);
+            const actual = this.getFileContent(this.activeFile.fileName).substring(this.currentCaretPosition, this.currentCaretPosition + text.length);
             if (actual !== text) {
                 throw new Error("verifyTextAtCaretIs\n" +
                     "\tExpected: \"" + text + "\"\n" +
@@ -1780,14 +1780,14 @@ namespace FourSlash {
         public verifyCurrentNameOrDottedNameSpanText(text: string) {
             this.taoInvalidReason = "verifyCurrentNameOrDottedNameSpanText NYI";
 
-            let span = this.languageService.getNameOrDottedNameSpan(this.activeFile.fileName, this.currentCaretPosition, this.currentCaretPosition);
+            const span = this.languageService.getNameOrDottedNameSpan(this.activeFile.fileName, this.currentCaretPosition, this.currentCaretPosition);
             if (!span) {
                 this.raiseError("verifyCurrentNameOrDottedNameSpanText\n" +
                     "\tExpected: \"" + text + "\"\n" +
                     "\t  Actual: undefined");
             }
 
-            let actual = this.getFileContent(this.activeFile.fileName).substring(span.start, ts.textSpanEnd(span));
+            const actual = this.getFileContent(this.activeFile.fileName).substring(span.start, ts.textSpanEnd(span));
             if (actual !== text) {
                 this.raiseError("verifyCurrentNameOrDottedNameSpanText\n" +
                     "\tExpected: \"" + text + "\"\n" +
@@ -1825,10 +1825,10 @@ namespace FourSlash {
             }
 
             for (let i = 0; i < expected.length; i++) {
-                let expectedClassification = expected[i];
-                let actualClassification = actual[i];
+                const expectedClassification = expected[i];
+                const actualClassification = actual[i];
 
-                let expectedType: string = (<any>ts.ClassificationTypeNames)[expectedClassification.classificationType];
+                const expectedType: string = (<any>ts.ClassificationTypeNames)[expectedClassification.classificationType];
                 if (expectedType !== actualClassification.classificationType) {
                     this.raiseError("verifyClassifications failed - expected classifications type to be " +
                         expectedType + ", but was " +
@@ -1836,11 +1836,11 @@ namespace FourSlash {
                         jsonMismatchString());
                 }
 
-                let expectedSpan = expectedClassification.textSpan;
-                let actualSpan = actualClassification.textSpan;
+                const expectedSpan = expectedClassification.textSpan;
+                const actualSpan = actualClassification.textSpan;
 
                 if (expectedSpan) {
-                    let expectedLength = expectedSpan.end - expectedSpan.start;
+                    const expectedLength = expectedSpan.end - expectedSpan.start;
 
                     if (expectedSpan.start !== actualSpan.start || expectedLength !== actualSpan.length) {
                         this.raiseError("verifyClassifications failed - expected span of text to be " +
@@ -1850,7 +1850,7 @@ namespace FourSlash {
                     }
                 }
 
-                let actualText = this.activeFile.content.substr(actualSpan.start, actualSpan.length);
+                const actualText = this.activeFile.content.substr(actualSpan.start, actualSpan.length);
                 if (expectedClassification.text !== actualText) {
                     this.raiseError("verifyClassifications failed - expected classified text to be " +
                         expectedClassification.text + ", but was " +
@@ -1868,7 +1868,7 @@ namespace FourSlash {
 
         public verifyProjectInfo(expected: string[]) {
             if (this.testType === FourSlashTestType.Server) {
-                let actual = (<ts.server.SessionClient>this.languageService).getProjectInfo(
+                const actual = (<ts.server.SessionClient>this.languageService).getProjectInfo(
                     this.activeFile.fileName,
                     /* needFileNameList */ true
                     );
@@ -1882,14 +1882,14 @@ namespace FourSlash {
         }
 
         public verifySemanticClassifications(expected: { classificationType: string; text: string }[]) {
-            let actual = this.languageService.getSemanticClassifications(this.activeFile.fileName,
+            const actual = this.languageService.getSemanticClassifications(this.activeFile.fileName,
                 ts.createTextSpan(0, this.activeFile.content.length));
 
             this.verifyClassifications(expected, actual);
         }
 
         public verifySyntacticClassifications(expected: { classificationType: string; text: string }[]) {
-            let actual = this.languageService.getSyntacticClassifications(this.activeFile.fileName,
+            const actual = this.languageService.getSyntacticClassifications(this.activeFile.fileName,
                 ts.createTextSpan(0, this.activeFile.content.length));
 
             this.verifyClassifications(expected, actual);
@@ -1898,15 +1898,15 @@ namespace FourSlash {
         public verifyOutliningSpans(spans: TextSpan[]) {
             this.taoInvalidReason = "verifyOutliningSpans NYI";
 
-            let actual = this.languageService.getOutliningSpans(this.activeFile.fileName);
+            const actual = this.languageService.getOutliningSpans(this.activeFile.fileName);
 
             if (actual.length !== spans.length) {
                 this.raiseError(`verifyOutliningSpans failed - expected total spans to be ${spans.length}, but was ${actual.length}`);
             }
 
             for (let i = 0; i < spans.length; i++) {
-                let expectedSpan = spans[i];
-                let actualSpan = actual[i];
+                const expectedSpan = spans[i];
+                const actualSpan = actual[i];
                 if (expectedSpan.start !== actualSpan.textSpan.start || expectedSpan.end !== ts.textSpanEnd(actualSpan.textSpan)) {
                     this.raiseError(`verifyOutliningSpans failed - span ${(i + 1)} expected: (${expectedSpan.start},${expectedSpan.end}),  actual: (${actualSpan.textSpan.start},${ts.textSpanEnd(actualSpan.textSpan)})`);
                 }
@@ -1914,7 +1914,7 @@ namespace FourSlash {
         }
 
         public verifyTodoComments(descriptors: string[], spans: TextSpan[]) {
-            let actual = this.languageService.getTodoComments(this.activeFile.fileName,
+            const actual = this.languageService.getTodoComments(this.activeFile.fileName,
                 descriptors.map(d => { return { text: d, priority: 0 }; }));
 
             if (actual.length !== spans.length) {
@@ -1922,9 +1922,9 @@ namespace FourSlash {
             }
 
             for (let i = 0; i < spans.length; i++) {
-                let expectedSpan = spans[i];
-                let actualComment = actual[i];
-                let actualCommentSpan = ts.createTextSpan(actualComment.position, actualComment.message.length);
+                const expectedSpan = spans[i];
+                const actualComment = actual[i];
+                const actualCommentSpan = ts.createTextSpan(actualComment.position, actualComment.message.length);
 
                 if (expectedSpan.start !== actualCommentSpan.start || expectedSpan.end !== ts.textSpanEnd(actualCommentSpan)) {
                     this.raiseError(`verifyOutliningSpans failed - span ${(i + 1)} expected: (${expectedSpan.start},${expectedSpan.end}),  actual: (${actualCommentSpan.start},${ts.textSpanEnd(actualCommentSpan)})`);
@@ -1934,7 +1934,7 @@ namespace FourSlash {
 
         public verifyDocCommentTemplate(expected?: ts.TextInsertion) {
             const name = "verifyDocCommentTemplate";
-            let actual = this.languageService.getDocCommentTemplateAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            const actual = this.languageService.getDocCommentTemplateAtPosition(this.activeFile.fileName, this.currentCaretPosition);
 
             if (expected === undefined) {
                 if (actual) {
@@ -1968,7 +1968,7 @@ namespace FourSlash {
         public verifyMatchingBracePosition(bracePosition: number, expectedMatchPosition: number) {
             this.taoInvalidReason = "verifyMatchingBracePosition NYI";
 
-            let actual = this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, bracePosition);
+            const actual = this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, bracePosition);
 
             if (actual.length !== 2) {
                 this.raiseError(`verifyMatchingBracePosition failed - expected result to contain 2 spans, but it had ${actual.length}`);
@@ -1993,7 +1993,7 @@ namespace FourSlash {
         public verifyNoMatchingBracePosition(bracePosition: number) {
             this.taoInvalidReason = "verifyNoMatchingBracePosition NYI";
 
-            let actual = this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, bracePosition);
+            const actual = this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, bracePosition);
 
             if (actual.length !== 0) {
                 this.raiseError("verifyNoMatchingBracePosition failed - expected: 0 spans, actual: " + actual.length);
@@ -2007,7 +2007,7 @@ namespace FourSlash {
         public verifyNavigationItemsCount(expected: number, searchValue: string, matchKind?: string) {
             this.taoInvalidReason = "verifyNavigationItemsCount NYI";
 
-            let items = this.languageService.getNavigateToItems(searchValue);
+            const items = this.languageService.getNavigateToItems(searchValue);
             let actual = 0;
             let item: ts.NavigateToItem = null;
 
@@ -2037,14 +2037,14 @@ namespace FourSlash {
             parentName?: string) {
             this.taoInvalidReason = "verifyNavigationItemsListContains NYI";
 
-            let items = this.languageService.getNavigateToItems(searchValue);
+            const items = this.languageService.getNavigateToItems(searchValue);
 
             if (!items || items.length === 0) {
                 this.raiseError("verifyNavigationItemsListContains failed - found 0 navigation items, expected at least one.");
             }
 
             for (let i = 0; i < items.length; i++) {
-                let item = items[i];
+                const item = items[i];
                 if (item && item.name === name && item.kind === kind &&
                     (matchKind === undefined || item.matchKind === matchKind) &&
                     (fileName === undefined || item.fileName === fileName) &&
@@ -2055,7 +2055,7 @@ namespace FourSlash {
 
             // if there was an explicit match kind specified, then it should be validated.
             if (matchKind !== undefined) {
-                let missingItem = { name: name, kind: kind, searchValue: searchValue, matchKind: matchKind, fileName: fileName, parentName: parentName };
+                const missingItem = { name: name, kind: kind, searchValue: searchValue, matchKind: matchKind, fileName: fileName, parentName: parentName };
                 this.raiseError(`verifyNavigationItemsListContains failed - could not find the item: ${JSON.stringify(missingItem)} in the returned list: (${JSON.stringify(items)})`);
             }
         }
@@ -2063,8 +2063,8 @@ namespace FourSlash {
         public verifyGetScriptLexicalStructureListCount(expected: number) {
             this.taoInvalidReason = "verifyNavigationItemsListContains impossible";
 
-            let items = this.languageService.getNavigationBarItems(this.activeFile.fileName);
-            let actual = this.getNavigationBarItemsCount(items);
+            const items = this.languageService.getNavigationBarItems(this.activeFile.fileName);
+            const actual = this.getNavigationBarItemsCount(items);
 
             if (expected !== actual) {
                 this.raiseError(`verifyGetScriptLexicalStructureListCount failed - found: ${actual} navigation items, expected: ${expected}.`);
@@ -2086,7 +2086,7 @@ namespace FourSlash {
         public verifyGetScriptLexicalStructureListContains(name: string, kind: string) {
             this.taoInvalidReason = "verifyGetScriptLexicalStructureListContains impossible";
 
-            let items = this.languageService.getNavigationBarItems(this.activeFile.fileName);
+            const items = this.languageService.getNavigationBarItems(this.activeFile.fileName);
 
             if (!items || items.length === 0) {
                 this.raiseError("verifyGetScriptLexicalStructureListContains failed - found 0 navigation items, expected at least one.");
@@ -2096,14 +2096,14 @@ namespace FourSlash {
                 return;
             }
 
-            let missingItem = { name: name, kind: kind };
+            const missingItem = { name: name, kind: kind };
             this.raiseError(`verifyGetScriptLexicalStructureListContains failed - could not find the item: ${JSON.stringify(missingItem)} in the returned list: (${JSON.stringify(items, null, " ")})`);
         }
 
         private navigationBarItemsContains(items: ts.NavigationBarItem[], name: string, kind: string) {
             if (items) {
                 for (let i = 0; i < items.length; i++) {
-                    let item = items[i];
+                    const item = items[i];
                     if (item && item.text === name && item.kind === kind) {
                         return true;
                     }
@@ -2118,25 +2118,25 @@ namespace FourSlash {
         }
 
         public printNavigationItems(searchValue: string) {
-            let items = this.languageService.getNavigateToItems(searchValue);
-            let length = items && items.length;
+            const items = this.languageService.getNavigateToItems(searchValue);
+            const length = items && items.length;
 
             Harness.IO.log(`NavigationItems list (${length} items)`);
 
             for (let i = 0; i < length; i++) {
-                let item = items[i];
+                const item = items[i];
                 Harness.IO.log(`name: ${item.name}, kind: ${item.kind}, parentName: ${item.containerName}, fileName: ${item.fileName}`);
             }
         }
 
         public printScriptLexicalStructureItems() {
-            let items = this.languageService.getNavigationBarItems(this.activeFile.fileName);
-            let length = items && items.length;
+            const items = this.languageService.getNavigationBarItems(this.activeFile.fileName);
+            const length = items && items.length;
 
             Harness.IO.log(`NavigationItems list (${length} items)`);
 
             for (let i = 0; i < length; i++) {
-                let item = items[i];
+                const item = items[i];
                 Harness.IO.log(`name: ${item.text}, kind: ${item.kind}`);
             }
         }
@@ -2148,13 +2148,13 @@ namespace FourSlash {
         public verifyOccurrencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean) {
             this.taoInvalidReason = "verifyOccurrencesAtPositionListContains NYI";
 
-            let occurrences = this.getOccurrencesAtCurrentPosition();
+            const occurrences = this.getOccurrencesAtCurrentPosition();
 
             if (!occurrences || occurrences.length === 0) {
                 this.raiseError("verifyOccurrencesAtPositionListContains failed - found 0 references, expected at least one.");
             }
 
-            for (let occurrence of occurrences) {
+            for (const occurrence of occurrences) {
                 if (occurrence && occurrence.fileName === fileName && occurrence.textSpan.start === start && ts.textSpanEnd(occurrence.textSpan) === end) {
                     if (typeof isWriteAccess !== "undefined" && occurrence.isWriteAccess !== isWriteAccess) {
                         this.raiseError(`verifyOccurrencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ${occurrence.isWriteAccess}, expected: ${isWriteAccess}.`);
@@ -2163,39 +2163,39 @@ namespace FourSlash {
                 }
             }
 
-            let missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };
+            const missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };
             this.raiseError(`verifyOccurrencesAtPositionListContains failed - could not find the item: ${JSON.stringify(missingItem)} in the returned list: (${JSON.stringify(occurrences)})`);
         }
 
         public verifyOccurrencesAtPositionListCount(expectedCount: number) {
             this.taoInvalidReason = "verifyOccurrencesAtPositionListCount NYI";
 
-            let occurrences = this.getOccurrencesAtCurrentPosition();
-            let actualCount = occurrences ? occurrences.length : 0;
+            const occurrences = this.getOccurrencesAtCurrentPosition();
+            const actualCount = occurrences ? occurrences.length : 0;
             if (expectedCount !== actualCount) {
                 this.raiseError(`verifyOccurrencesAtPositionListCount failed - actual: ${actualCount}, expected:${expectedCount}`);
             }
         }
 
         private getDocumentHighlightsAtCurrentPosition(fileNamesToSearch: string[]) {
-            let filesToSearch = fileNamesToSearch.map(name => ts.combinePaths(this.basePath, name));
+            const filesToSearch = fileNamesToSearch.map(name => ts.combinePaths(this.basePath, name));
             return this.languageService.getDocumentHighlights(this.activeFile.fileName, this.currentCaretPosition, filesToSearch);
         }
 
         public verifyDocumentHighlightsAtPositionListContains(fileName: string, start: number, end: number, fileNamesToSearch: string[], kind?: string) {
             this.taoInvalidReason = "verifyDocumentHighlightsAtPositionListContains NYI";
 
-            let documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch);
+            const documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch);
 
             if (!documentHighlights || documentHighlights.length === 0) {
                 this.raiseError("verifyDocumentHighlightsAtPositionListContains failed - found 0 highlights, expected at least one.");
             }
 
-            for (let documentHighlight of documentHighlights) {
+            for (const documentHighlight of documentHighlights) {
                 if (documentHighlight.fileName === fileName) {
-                    let { highlightSpans } = documentHighlight;
+                    const { highlightSpans } = documentHighlight;
 
-                    for (let highlight of highlightSpans) {
+                    for (const highlight of highlightSpans) {
                         if (highlight && highlight.textSpan.start === start && ts.textSpanEnd(highlight.textSpan) === end) {
                             if (typeof kind !== "undefined" && highlight.kind !== kind) {
                                 this.raiseError(`verifyDocumentHighlightsAtPositionListContains failed - item "kind" value does not match, actual: ${highlight.kind}, expected: ${kind}.`);
@@ -2206,15 +2206,15 @@ namespace FourSlash {
                 }
             }
 
-            let missingItem = { fileName: fileName, start: start, end: end, kind: kind };
+            const missingItem = { fileName: fileName, start: start, end: end, kind: kind };
             this.raiseError(`verifyDocumentHighlightsAtPositionListContains failed - could not find the item: ${JSON.stringify(missingItem)} in the returned list: (${JSON.stringify(documentHighlights)})`);
         }
 
         public verifyDocumentHighlightsAtPositionListCount(expectedCount: number, fileNamesToSearch: string[]) {
             this.taoInvalidReason = "verifyDocumentHighlightsAtPositionListCount NYI";
 
-            let documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch);
-            let actualCount = documentHighlights
+            const documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch);
+            const actualCount = documentHighlights
                 ? documentHighlights.reduce((currentCount, { highlightSpans }) => currentCount + highlightSpans.length, 0)
                 : 0;
 
@@ -2225,13 +2225,13 @@ namespace FourSlash {
 
         // Get the text of the entire line the caret is currently at
         private getCurrentLineContent() {
-            let text = this.getFileContent(this.activeFile.fileName);
+            const text = this.getFileContent(this.activeFile.fileName);
 
-            let pos = this.currentCaretPosition;
+            const pos = this.currentCaretPosition;
             let startPos = pos, endPos = pos;
 
             while (startPos > 0) {
-                let ch = text.charCodeAt(startPos - 1);
+                const ch = text.charCodeAt(startPos - 1);
                 if (ch === ts.CharacterCodes.carriageReturn || ch === ts.CharacterCodes.lineFeed) {
                     break;
                 }
@@ -2240,7 +2240,7 @@ namespace FourSlash {
             }
 
             while (endPos < text.length) {
-                let ch = text.charCodeAt(endPos);
+                const ch = text.charCodeAt(endPos);
 
                 if (ch === ts.CharacterCodes.carriageReturn || ch === ts.CharacterCodes.lineFeed) {
                     break;
@@ -2261,10 +2261,10 @@ namespace FourSlash {
             }
 
             for (let i = 0; i < items.length; i++) {
-                let item = items[i];
+                const item = items[i];
                 if (item.name === name) {
                     if (documentation != undefined || text !== undefined) {
-                        let details = this.getCompletionEntryDetails(item.name);
+                        const details = this.getCompletionEntryDetails(item.name);
 
                         if (documentation !== undefined) {
                             assert.equal(ts.displayPartsToString(details.documentation), documentation, assertionMessage("completion item documentation"));
@@ -2282,7 +2282,7 @@ namespace FourSlash {
                 }
             }
 
-            let itemsString = items.map((item) => JSON.stringify({ name: item.name, kind: item.kind })).join(",\n");
+            const itemsString = items.map((item) => JSON.stringify({ name: item.name, kind: item.kind })).join(",\n");
 
             this.raiseError(`Expected "${JSON.stringify({ name, text, documentation, kind })}" to be in list [${itemsString}]`);
         }
@@ -2290,7 +2290,7 @@ namespace FourSlash {
         private findFile(indexOrName: any) {
             let result: FourSlashFile = null;
             if (typeof indexOrName === "number") {
-                let index = <number>indexOrName;
+                const index = <number>indexOrName;
                 if (index >= this.testData.files.length) {
                     throw new Error(`File index (${index}) in openFile was out of range. There are only ${this.testData.files.length} files in this test.`);
                 }
@@ -2304,10 +2304,10 @@ namespace FourSlash {
                 // names are stored in the compiler with this relative path, this allows people to use goTo.file on just the fileName
                 name = name.indexOf("/") === -1 ? (this.basePath + "/" + name) : name;
 
-                let availableNames: string[] = [];
+                const availableNames: string[] = [];
                 let foundIt = false;
                 for (let i = 0; i < this.testData.files.length; i++) {
-                    let fn = this.testData.files[i].fileName;
+                    const fn = this.testData.files[i].fileName;
                     if (fn) {
                         if (fn === name) {
                             result = this.testData.files[i];
@@ -2330,15 +2330,15 @@ namespace FourSlash {
         }
 
         private getLineColStringAtPosition(position: number) {
-            let pos = this.languageServiceAdapterHost.positionToLineAndCharacter(this.activeFile.fileName, position);
+            const pos = this.languageServiceAdapterHost.positionToLineAndCharacter(this.activeFile.fileName, position);
             return `line ${(pos.line + 1)}, col ${pos.character}`;
         }
 
         public getMarkerByName(markerName: string) {
-            let markerPos = this.testData.markerPositions[markerName];
+            const markerPos = this.testData.markerPositions[markerName];
             if (markerPos === undefined) {
-                let markerNames: string[] = [];
-                for (let m in this.testData.markerPositions) markerNames.push(m);
+                const markerNames: string[] = [];
+                for (const m in this.testData.markerPositions) markerNames.push(m);
                 throw new Error(`Unknown marker "${markerName}" Available markers: ${markerNames.map(m => "\"" + m + "\"").join(", ")}`);
             }
             else {
@@ -2368,12 +2368,12 @@ namespace FourSlash {
     }
 
     // TOOD: should these just use the Harness's stdout/stderr?
-    let fsOutput = new Harness.Compiler.WriterAggregator();
-    let fsErrors = new Harness.Compiler.WriterAggregator();
+    const fsOutput = new Harness.Compiler.WriterAggregator();
+    const fsErrors = new Harness.Compiler.WriterAggregator();
     export let xmlData: TestXmlData[] = [];
     export function runFourSlashTest(basePath: string, testType: FourSlashTestType, fileName: string) {
-        let content = Harness.IO.readFile(fileName);
-        let xml = runFourSlashTestContent(basePath, testType, content, fileName);
+        const content = Harness.IO.readFile(fileName);
+        const xml = runFourSlashTestContent(basePath, testType, content, fileName);
         xmlData.push(xml);
     }
 
@@ -2381,12 +2381,12 @@ namespace FourSlash {
     // here we cache the JS output and reuse it for every test.
     let fourslashJsOutput: string;
     {
-        let host = Harness.Compiler.createCompilerHost([{ unitName: Harness.Compiler.fourslashFileName, content: undefined }],
+        const host = Harness.Compiler.createCompilerHost([{ unitName: Harness.Compiler.fourslashFileName, content: undefined }],
             (fn, contents) => fourslashJsOutput = contents,
             ts.ScriptTarget.Latest,
             Harness.IO.useCaseSensitiveFileNames());
 
-        let program = ts.createProgram([Harness.Compiler.fourslashFileName], { noResolve: true, target: ts.ScriptTarget.ES3 }, host);
+        const program = ts.createProgram([Harness.Compiler.fourslashFileName], { noResolve: true, target: ts.ScriptTarget.ES3 }, host);
 
         program.emit(host.getSourceFile(Harness.Compiler.fourslashFileName, ts.ScriptTarget.ES3));
     }
@@ -2394,12 +2394,12 @@ namespace FourSlash {
 
     export function runFourSlashTestContent(basePath: string, testType: FourSlashTestType, content: string, fileName: string): TestXmlData {
         // Parse out the files and their metadata
-        let testData = parseTestData(basePath, content, fileName);
+        const testData = parseTestData(basePath, content, fileName);
 
         currentTestState = new TestState(basePath, testType, testData);
 
         let result = "";
-        let host = Harness.Compiler.createCompilerHost(
+        const host = Harness.Compiler.createCompilerHost(
             [
                 { unitName: Harness.Compiler.fourslashFileName, content: undefined },
                 { unitName: fileName, content: content }
@@ -2408,11 +2408,11 @@ namespace FourSlash {
             ts.ScriptTarget.Latest,
             Harness.IO.useCaseSensitiveFileNames());
 
-        let program = ts.createProgram([Harness.Compiler.fourslashFileName, fileName], { outFile: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);
+        const program = ts.createProgram([Harness.Compiler.fourslashFileName, fileName], { outFile: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);
 
-        let sourceFile = host.getSourceFile(fileName, ts.ScriptTarget.ES3);
+        const sourceFile = host.getSourceFile(fileName, ts.ScriptTarget.ES3);
 
-        let diagnostics = ts.getPreEmitDiagnostics(program, sourceFile);
+        const diagnostics = ts.getPreEmitDiagnostics(program, sourceFile);
         if (diagnostics.length > 0) {
             throw new Error(`Error compiling ${fileName}: ` +
                 diagnostics.map(e => ts.flattenDiagnosticMessageText(e.messageText, Harness.IO.newLine())).join("\r\n"));
@@ -2432,13 +2432,13 @@ namespace FourSlash {
             throw err;
         }
 
-        let xmlData = currentTestState.getTestXmlData();
+        const xmlData = currentTestState.getTestXmlData();
         xmlData.originalName = fileName;
         return xmlData;
     }
 
     function chompLeadingSpace(content: string) {
-        let lines = content.split("\n");
+        const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
             if ((lines[i].length !== 0) && (lines[i].charAt(0) !== " ")) {
                 return content;
@@ -2450,22 +2450,22 @@ namespace FourSlash {
 
     function parseTestData(basePath: string, contents: string, fileName: string): FourSlashData {
         // Regex for parsing options in the format "@Alpha: Value of any sort"
-        let optionRegex = /^\s*@(\w+): (.*)\s*/;
+        const optionRegex = /^\s*@(\w+): (.*)\s*/;
 
         // List of all the subfiles we've parsed out
-        let files: FourSlashFile[] = [];
+        const files: FourSlashFile[] = [];
         // Global options
-        let globalOptions: { [s: string]: string; } = {};
+        const globalOptions: { [s: string]: string; } = {};
         // Marker positions
 
         // Split up the input file by line
         // Note: IE JS engine incorrectly handles consecutive delimiters here when using RegExp split, so
         // we have to string-based splitting instead and try to figure out the delimiting chars
-        let lines = contents.split("\n");
+        const lines = contents.split("\n");
 
-        let markerPositions: MarkerMap = {};
-        let markers: Marker[] = [];
-        let ranges: Range[] = [];
+        const markerPositions: MarkerMap = {};
+        const markers: Marker[] = [];
+        const ranges: Range[] = [];
 
         // Stuff related to the subfile we're parsing
         let currentFileContent: string = null;
@@ -2474,7 +2474,7 @@ namespace FourSlash {
 
         for (let i = 0; i < lines.length; i++) {
             let line = lines[i];
-            let lineLength = line.length;
+            const lineLength = line.length;
 
             if (lineLength > 0 && line.charAt(lineLength - 1) === "\r") {
                 line = line.substr(0, lineLength - 1);
@@ -2496,9 +2496,9 @@ namespace FourSlash {
             }
             else if (line.substr(0, 2) === "//") {
                 // Comment line, check for global/file @options and record them
-                let match = optionRegex.exec(line.substr(2));
+                const match = optionRegex.exec(line.substr(2));
                 if (match) {
-                    let fileMetadataNamesIndex = fileMetadataNames.indexOf(match[1]);
+                    const fileMetadataNamesIndex = fileMetadataNames.indexOf(match[1]);
                     if (fileMetadataNamesIndex === -1) {
                         // Check if the match is already existed in the global options
                         if (globalOptions[match[1]] !== undefined) {
@@ -2510,7 +2510,7 @@ namespace FourSlash {
                         if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
                             // Found an @FileName directive, if this is not the first then create a new subfile
                             if (currentFileContent) {
-                                let file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);
+                                const file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);
                                 file.fileOptions = currentFileOptions;
 
                                 // Store result file
@@ -2540,7 +2540,7 @@ namespace FourSlash {
             else {
                 // Empty line or code line, terminate current subfile if there is one
                 if (currentFileContent) {
-                    let file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);
+                    const file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);
                     file.fileOptions = currentFileOptions;
 
                     // Store result file
@@ -2583,7 +2583,7 @@ namespace FourSlash {
     }
 
     function getNonFileNameOptionInObject(optionObject: { [s: string]: string }): string {
-        for (let option in optionObject) {
+        for (const option in optionObject) {
             if (option !== metadataOptionNames.fileName) {
                 return option;
             }
@@ -2598,7 +2598,7 @@ namespace FourSlash {
     }
 
     function reportError(fileName: string, line: number, col: number, message: string) {
-        let errorMessage = fileName + "(" + line + "," + col + "): " + message;
+        const errorMessage = fileName + "(" + line + "," + col + "): " + message;
         throw new Error(errorMessage);
     }
 
@@ -2617,7 +2617,7 @@ namespace FourSlash {
             return null;
         }
 
-        let marker: Marker = {
+        const marker: Marker = {
             fileName: fileName,
             position: location.position,
             data: markerValue
@@ -2634,14 +2634,14 @@ namespace FourSlash {
     }
 
     function recordMarker(fileName: string, location: ILocationInformation, name: string, markerMap: MarkerMap, markers: Marker[]): Marker {
-        let marker: Marker = {
+        const marker: Marker = {
             fileName: fileName,
             position: location.position
         };
 
         // Verify markers for uniqueness
         if (markerMap[name] !== undefined) {
-            let message = "Marker '" + name + "' is duplicated in the source file contents.";
+            const message = "Marker '" + name + "' is duplicated in the source file contents.";
             reportError(marker.fileName, location.sourceLine, location.sourceColumn, message);
             return null;
         }
@@ -2656,7 +2656,7 @@ namespace FourSlash {
         content = chompLeadingSpace(content);
 
         // Any slash-star comment with a character not in this string is not a marker.
-        let validMarkerChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$1234567890_";
+        const validMarkerChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$1234567890_";
 
         /// The file content (minus metacharacters) so far
         let output = "";
@@ -2665,7 +2665,7 @@ namespace FourSlash {
         let openMarker: ILocationInformation = null;
 
         /// A stack of the open range markers that are still unclosed
-        let openRanges: IRangeLocationInformation[] = [];
+        const openRanges: IRangeLocationInformation[] = [];
 
         /// A list of ranges we've collected so far */
         let localRanges: Range[] = [];
@@ -2683,7 +2683,7 @@ namespace FourSlash {
         let line = 1;
         let column = 1;
 
-        let flush = (lastSafeCharIndex: number) => {
+        const flush = (lastSafeCharIndex: number) => {
             if (lastSafeCharIndex === undefined) {
                 output = output + content.substr(lastNormalCharPosition);
             }
@@ -2695,7 +2695,7 @@ namespace FourSlash {
         if (content.length > 0) {
             let previousChar = content.charAt(0);
             for (let i = 1; i < content.length; i++) {
-                let currentChar = content.charAt(i);
+                const currentChar = content.charAt(i);
                 switch (state) {
                     case State.none:
                         if (previousChar === "[" && currentChar === "|") {
@@ -2713,12 +2713,12 @@ namespace FourSlash {
                         }
                         else if (previousChar === "|" && currentChar === "]") {
                             // found a range end
-                            let rangeStart = openRanges.pop();
+                            const rangeStart = openRanges.pop();
                             if (!rangeStart) {
                                 reportError(fileName, line, column, "Found range end with no matching start.");
                             }
 
-                            let range: Range = {
+                            const range: Range = {
                                 fileName: fileName,
                                 start: rangeStart.position,
                                 end: (i - 1) - difference,
@@ -2758,8 +2758,8 @@ namespace FourSlash {
                         // Object markers are only ever terminated by |} and have no content restrictions
                         if (previousChar === "|" && currentChar === "}") {
                             // Record the marker
-                            let objectMarkerNameText = content.substring(openMarker.sourcePosition + 2, i - 1).trim();
-                            let marker = recordObjectMarker(fileName, openMarker, objectMarkerNameText, markerMap, markers);
+                            const objectMarkerNameText = content.substring(openMarker.sourcePosition + 2, i - 1).trim();
+                            const marker = recordObjectMarker(fileName, openMarker, objectMarkerNameText, markerMap, markers);
 
                             if (openRanges.length > 0) {
                                 openRanges[openRanges.length - 1].marker = marker;
@@ -2779,8 +2779,8 @@ namespace FourSlash {
                         if (previousChar === "*" && currentChar === "/") {
                             // Record the marker
                             // start + 2 to ignore the */, -1 on the end to ignore the * (/ is next)
-                            let markerNameText = content.substring(openMarker.sourcePosition + 2, i - 1).trim();
-                            let marker = recordMarker(fileName, openMarker, markerNameText, markerMap, markers);
+                            const markerNameText = content.substring(openMarker.sourcePosition + 2, i - 1).trim();
+                            const marker = recordMarker(fileName, openMarker, markerNameText, markerMap, markers);
 
                             if (openRanges.length > 0) {
                                 openRanges[openRanges.length - 1].marker = marker;
@@ -2831,7 +2831,7 @@ namespace FourSlash {
         flush(undefined);
 
         if (openRanges.length > 0) {
-            let openRange = openRanges[0];
+            const openRange = openRanges[0];
             reportError(fileName, openRange.sourceLine, openRange.sourceColumn, "Unterminated range.");
         }
 
diff --git a/src/harness/fourslashRunner.ts b/src/harness/fourslashRunner.ts
index 867c0d5a4d6..7228f06c20f 100644
--- a/src/harness/fourslashRunner.ts
+++ b/src/harness/fourslashRunner.ts
@@ -45,10 +45,10 @@ class FourSlashRunner extends RunnerBase {
             this.tests.forEach((fn: string) => {
                  describe(fn, () => {
                        fn = ts.normalizeSlashes(fn);
-                        let justName = fn.replace(/^.*[\\\/]/, "");
+                        const justName = fn.replace(/^.*[\\\/]/, "");
 
                         // Convert to relative path
-                        let testIndex = fn.indexOf("tests/");
+                        const testIndex = fn.indexOf("tests/");
                         if (testIndex >= 0) fn = fn.substr(testIndex);
 
                         if (justName && !justName.match(/fourslash\.ts$/i) && !justName.match(/\.d\.ts$/i)) {
@@ -60,21 +60,21 @@ class FourSlashRunner extends RunnerBase {
             });
 
             describe("Generate Tao XML", () => {
-                let invalidReasons: any = {};
+                const invalidReasons: any = {};
                 FourSlash.xmlData.forEach(xml => {
                     if (xml.invalidReason !== null) {
                         invalidReasons[xml.invalidReason] = (invalidReasons[xml.invalidReason] || 0) + 1;
                     }
                 });
-                let invalidReport: { reason: string; count: number }[] = [];
-                for (let reason in invalidReasons) {
+                const invalidReport: { reason: string; count: number }[] = [];
+                for (const reason in invalidReasons) {
                     if (invalidReasons.hasOwnProperty(reason)) {
                         invalidReport.push({ reason: reason, count: invalidReasons[reason] });
                     }
                 }
                 invalidReport.sort((lhs, rhs) => lhs.count > rhs.count ? -1 : lhs.count === rhs.count ? 0 : 1);
 
-                let lines: string[] = [];
+                const lines: string[] = [];
                 lines.push("<!-- Blocked Test Report");
                 invalidReport.forEach((reasonAndCount) => {
                     lines.push(reasonAndCount.count + " tests blocked by " + reasonAndCount.reason);
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index cd27fd559b2..5b7c04f3e3c 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -67,7 +67,7 @@ namespace Utils {
     }
 
     export function evalFile(fileContents: string, fileName: string, nodeContext?: any) {
-        let environment = getExecutionEnvironment();
+        const environment = getExecutionEnvironment();
         switch (environment) {
             case ExecutionEnvironment.CScript:
             case ExecutionEnvironment.Browser:
@@ -121,11 +121,11 @@ namespace Utils {
     }
 
     export function memoize<T extends Function>(f: T): T {
-        let cache: { [idx: string]: any } = {};
+        const cache: { [idx: string]: any } = {};
 
         return <any>(function () {
-            let key = Array.prototype.join.call(arguments);
-            let cachedResult = cache[key];
+            const key = Array.prototype.join.call(arguments);
+            const cachedResult = cache[key];
             if (cachedResult) {
                 return cachedResult;
             }
@@ -172,16 +172,16 @@ namespace Utils {
                     currentPos = array.end;
                 });
 
-            let childNodesAndArrays: any[] = [];
+            const childNodesAndArrays: any[] = [];
             ts.forEachChild(node, child => { childNodesAndArrays.push(child); }, array => { childNodesAndArrays.push(array); });
 
-            for (let childName in node) {
+            for (const childName in node) {
                 if (childName === "parent" || childName === "nextContainer" || childName === "modifiers" || childName === "externalModuleIndicator" ||
                     // for now ignore jsdoc comments
                     childName === "jsDocComment") {
                     continue;
                 }
-                let child = (<any>node)[childName];
+                const child = (<any>node)[childName];
                 if (isNodeOrArray(child)) {
                     assert.isFalse(childNodesAndArrays.indexOf(child) < 0,
                         "Missing child when forEach'ing over node: " + (<any>ts).SyntaxKind[node.kind] + "-" + childName);
@@ -249,7 +249,7 @@ namespace Utils {
         function getParserContextFlagName(f: number) { return getFlagName((<any>ts).ParserContextFlags, f); }
 
         function serializeNode(n: ts.Node): any {
-            let o: any = { kind: getKindName(n.kind) };
+            const o: any = { kind: getKindName(n.kind) };
             if (ts.containsParseError(n)) {
                 o.containsParseError = true;
             }
@@ -331,8 +331,8 @@ namespace Utils {
         assert.equal(array1.length, array2.length, "array1.length !== array2.length");
 
         for (let i = 0, n = array1.length; i < n; i++) {
-            let d1 = array1[i];
-            let d2 = array2[i];
+            const d1 = array1[i];
+            const d2 = array2[i];
 
             assert.equal(d1.start, d2.start, "d1.start !== d2.start");
             assert.equal(d1.length, d2.length, "d1.length !== d2.length");
@@ -363,14 +363,14 @@ namespace Utils {
 
         ts.forEachChild(node1,
             child1 => {
-                let childName = findChildName(node1, child1);
-                let child2: ts.Node = (<any>node2)[childName];
+                const childName = findChildName(node1, child1);
+                const child2: ts.Node = (<any>node2)[childName];
 
                 assertStructuralEquals(child1, child2);
             },
             (array1: ts.NodeArray<ts.Node>) => {
-                let childName = findChildName(node1, array1);
-                let array2: ts.NodeArray<ts.Node> = (<any>node2)[childName];
+                const childName = findChildName(node1, array1);
+                const array2: ts.NodeArray<ts.Node> = (<any>node2)[childName];
 
                 assertArrayStructuralEquals(array1, array2);
             });
@@ -393,7 +393,7 @@ namespace Utils {
     }
 
     function findChildName(parent: any, child: any) {
-        for (let name in parent) {
+        for (const name in parent) {
             if (parent.hasOwnProperty(name) && parent[name] === child) {
                 return name;
             }
@@ -410,8 +410,8 @@ namespace Harness.Path {
 
     export function filePath(fullPath: string) {
         fullPath = ts.normalizeSlashes(fullPath);
-        let components = fullPath.split("/");
-        let path: string[] = components.slice(0, components.length - 1);
+        const components = fullPath.split("/");
+        const path: string[] = components.slice(0, components.length - 1);
         return path.join("/") + "/";
     }
 }
@@ -512,15 +512,15 @@ namespace Harness {
                     return paths;
                 }
 
-                let folder: any = fso.GetFolder(path);
-                let paths: string[] = [];
+                const folder: any = fso.GetFolder(path);
+                const paths: string[] = [];
 
                 return filesInFolder(folder, path);
             };
         }
 
         export namespace Node {
-            declare let require: any;
+            declare const require: any;
             let fs: any, pathModule: any;
             if (require) {
                 fs = require("fs");
@@ -581,10 +581,10 @@ namespace Harness {
                 function filesInFolder(folder: string): string[] {
                     let paths: string[] = [];
 
-                    let files = fs.readdirSync(folder);
+                    const files = fs.readdirSync(folder);
                     for (let i = 0; i < files.length; i++) {
-                        let pathToFile = pathModule.join(folder, files[i]);
-                        let stat = fs.statSync(pathToFile);
+                        const pathToFile = pathModule.join(folder, files[i]);
+                        const stat = fs.statSync(pathToFile);
                         if (options.recursive && stat.isDirectory()) {
                             paths = paths.concat(filesInFolder(pathToFile));
                         }
@@ -608,7 +608,7 @@ namespace Harness {
         }
 
         export namespace Network {
-            let serverRoot = "http://localhost:8888/";
+            const serverRoot = "http://localhost:8888/";
 
             export const newLine = () => harnessNewLine;
             export const useCaseSensitiveFileNames = () => false;
@@ -617,7 +617,7 @@ namespace Harness {
             export const getExecutingFilePath = () => "";
             export const exit = (exitCode: number) => {};
 
-            let supportsCodePage = () => false;
+            const supportsCodePage = () => false;
             export let log = (s: string) => console.log(s);
 
             namespace Http {
@@ -628,7 +628,7 @@ namespace Harness {
 
                 /// Ask the server to use node's path.resolve to resolve the given path
                 function getResolvedPathFromServer(path: string) {
-                    let xhr = new XMLHttpRequest();
+                    const xhr = new XMLHttpRequest();
                     try {
                         xhr.open("GET", path + "?resolve", false);
                         xhr.send();
@@ -647,7 +647,7 @@ namespace Harness {
 
                 /// Ask the server for the contents of the file at the given URL via a simple GET request
                 export function getFileFromServerSync(url: string): XHRResponse {
-                    let xhr = new XMLHttpRequest();
+                    const xhr = new XMLHttpRequest();
                     try {
                         xhr.open("GET", url, false);
                         xhr.send();
@@ -661,9 +661,9 @@ namespace Harness {
 
                 /// Submit a POST request to the server to do the given action (ex WRITE, DELETE) on the provided URL
                 export function writeToServerSync(url: string, action: string, contents?: string): XHRResponse {
-                    let xhr = new XMLHttpRequest();
+                    const xhr = new XMLHttpRequest();
                     try {
-                        let actionMsg = "?action=" + action;
+                        const actionMsg = "?action=" + action;
                         xhr.open("POST", url + actionMsg, false);
                         xhr.setRequestHeader("Access-Control-Allow-Origin", "*");
                         xhr.send(contents);
@@ -714,14 +714,14 @@ namespace Harness {
             export const resolvePath = (path: string) => directoryName(path);
 
             export function fileExists(path: string): boolean {
-                let response = Http.getFileFromServerSync(serverRoot + path);
+                const response = Http.getFileFromServerSync(serverRoot + path);
                 return response.status === 200;
             }
 
             export function _listFilesImpl(path: string, spec?: RegExp, options?: any) {
-                let response = Http.getFileFromServerSync(serverRoot + path);
+                const response = Http.getFileFromServerSync(serverRoot + path);
                 if (response.status === 200) {
-                    let results = response.responseText.split(",");
+                    const results = response.responseText.split(",");
                     if (spec) {
                         return results.filter(file => spec.test(file));
                     }
@@ -736,7 +736,7 @@ namespace Harness {
             export let listFiles = Utils.memoize(_listFilesImpl);
 
             export function readFile(file: string) {
-                let response = Http.getFileFromServerSync(serverRoot + file);
+                const response = Http.getFileFromServerSync(serverRoot + file);
                 if (response.status === 200) {
                     return response.responseText;
                 }
@@ -858,10 +858,10 @@ namespace Harness {
             public reset() { this.fileCollection = {}; }
 
             public toArray(): { fileName: string; file: WriterAggregator; }[] {
-                let result: { fileName: string; file: WriterAggregator; }[] = [];
-                for (let p in this.fileCollection) {
+                const result: { fileName: string; file: WriterAggregator; }[] = [];
+                for (const p in this.fileCollection) {
                     if (this.fileCollection.hasOwnProperty(p)) {
-                        let current = <Harness.Compiler.WriterAggregator>this.fileCollection[p];
+                        const current = <Harness.Compiler.WriterAggregator>this.fileCollection[p];
                         if (current.lines.length > 0) {
                             if (p.indexOf(".d.ts") !== -1) { current.lines.unshift(["////[", Path.getFileName(p), "]"].join("")); }
                             result.push({ fileName: p, file: this.fileCollection[p] });
@@ -880,7 +880,7 @@ namespace Harness {
             const shouldAssertInvariants = !Harness.lightMode;
 
             // Only set the parent nodes if we're asserting inletiants.  We don't need them otherwise.
-            let result = ts.createSourceFile(fileName, sourceText, languageVersion, /*setParentNodes:*/ shouldAssertInvariants);
+            const result = ts.createSourceFile(fileName, sourceText, languageVersion, /*setParentNodes:*/ shouldAssertInvariants);
 
             if (shouldAssertInvariants) {
                 Utils.assertInvariants(result, /*parent:*/ undefined);
@@ -918,13 +918,13 @@ namespace Harness {
                 return useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
             }
 
-            let filemap: { [fileName: string]: ts.SourceFile; } = {};
-            let getCurrentDirectory = currentDirectory === undefined ? Harness.IO.getCurrentDirectory : () => currentDirectory;
+            const filemap: { [fileName: string]: ts.SourceFile; } = {};
+            const getCurrentDirectory = currentDirectory === undefined ? Harness.IO.getCurrentDirectory : () => currentDirectory;
 
             // Register input files
             function register(file: { unitName: string; content: string; }) {
                 if (file.content !== undefined) {
-                    let fileName = ts.normalizePath(file.unitName);
+                    const fileName = ts.normalizePath(file.unitName);
                     const sourceFile = createSourceFileAndAssertInvariants(fileName, file.content, scriptTarget);
                     filemap[getCanonicalFileName(fileName)] = sourceFile;
                     filemap[getCanonicalFileName(ts.getNormalizedAbsolutePath(fileName, getCurrentDirectory()))] = sourceFile;
@@ -938,11 +938,11 @@ namespace Harness {
                     return filemap[getCanonicalFileName(fn)];
                 }
                 else if (currentDirectory) {
-                    let canonicalAbsolutePath = getCanonicalFileName(ts.getNormalizedAbsolutePath(fn, currentDirectory));
+                    const canonicalAbsolutePath = getCanonicalFileName(ts.getNormalizedAbsolutePath(fn, currentDirectory));
                     return Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(canonicalAbsolutePath)) ? filemap[canonicalAbsolutePath] : undefined;
                 }
                 else if (fn === fourslashFileName) {
-                    let tsFn = "tests/cases/fourslash/" + fourslashFileName;
+                    const tsFn = "tests/cases/fourslash/" + fourslashFileName;
                     fourslashSourceFile = fourslashSourceFile || createSourceFileAndAssertInvariants(tsFn, Harness.IO.readFile(tsFn), scriptTarget);
                     return fourslashSourceFile;
                 }
@@ -955,7 +955,7 @@ namespace Harness {
                 }
             }
 
-            let newLine =
+            const newLine =
                 newLineKind === ts.NewLineKind.CarriageReturnLineFeed ? carriageReturnLineFeed :
                     newLineKind === ts.NewLineKind.LineFeed ? lineFeed :
                         Harness.IO.newLine();
@@ -993,8 +993,8 @@ namespace Harness {
         function getCommandLineOption(name: string): ts.CommandLineOption {
             if (!optionsIndex) {
                 optionsIndex = {};
-                let optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);
-                for (let option of optionDeclarations) {
+                const optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);
+                for (const option of optionDeclarations) {
                     optionsIndex[option.name.toLowerCase()] = option;
                 }
             }
@@ -1002,13 +1002,13 @@ namespace Harness {
         }
 
         export function setCompilerOptionsFromHarnessSetting(settings: Harness.TestCaseParser.CompilerSettings, options: ts.CompilerOptions & HarnessOptions): void {
-            for (let name in settings) {
+            for (const name in settings) {
                 if (settings.hasOwnProperty(name)) {
-                    let value = settings[name];
+                    const value = settings[name];
                     if (value === undefined) {
                         throw new Error(`Cannot have undefined value for compiler option '${name}'.`);
                     }
-                    let option = getCommandLineOption(name);
+                    const option = getCommandLineOption(name);
                     if (option) {
                         switch (option.type) {
                             case "boolean":
@@ -1104,37 +1104,37 @@ namespace Harness {
                     settingsCallback(null);
                 }
 
-                let newLine = "\r\n";
+                const newLine = "\r\n";
 
                 // Parse settings
                 setCompilerOptionsFromHarnessSetting(this.settings, options);
 
                 // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
                 // Treat them as library files, so include them in build, but not in baselines.
-                let includeBuiltFiles: { unitName: string; content: string }[] = [];
+                const includeBuiltFiles: { unitName: string; content: string }[] = [];
                 if (options.includeBuiltFile) {
-                    let builtFileName = libFolder + options.includeBuiltFile;
+                    const builtFileName = libFolder + options.includeBuiltFile;
                     includeBuiltFiles.push({ unitName: builtFileName, content: normalizeLineEndings(IO.readFile(builtFileName), newLine) });
                 }
 
-                let useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : Harness.IO.useCaseSensitiveFileNames();
+                const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : Harness.IO.useCaseSensitiveFileNames();
 
-                let fileOutputs: GeneratedFile[] = [];
+                const fileOutputs: GeneratedFile[] = [];
 
-                let programFiles = inputFiles.concat(includeBuiltFiles).map(file => file.unitName);
+                const programFiles = inputFiles.concat(includeBuiltFiles).map(file => file.unitName);
 
-                let compilerHost = createCompilerHost(
+                const compilerHost = createCompilerHost(
                     inputFiles.concat(includeBuiltFiles).concat(otherFiles),
                     (fn, contents, writeByteOrderMark) => fileOutputs.push({ fileName: fn, code: contents, writeByteOrderMark: writeByteOrderMark }),
                     options.target, useCaseSensitiveFileNames, currentDirectory, options.newLine);
-                let program = ts.createProgram(programFiles, options, compilerHost);
+                const program = ts.createProgram(programFiles, options, compilerHost);
 
-                let emitResult = program.emit();
+                const emitResult = program.emit();
 
-                let errors = ts.getPreEmitDiagnostics(program);
+                const errors = ts.getPreEmitDiagnostics(program);
                 this.lastErrors = errors;
 
-                let result = new CompilerResult(fileOutputs, errors, program, Harness.IO.getCurrentDirectory(), emitResult.sourceMaps);
+                const result = new CompilerResult(fileOutputs, errors, program, Harness.IO.getCurrentDirectory(), emitResult.sourceMaps);
                 onComplete(result, program);
 
                 return options;
@@ -1151,8 +1151,8 @@ namespace Harness {
                     throw new Error("There were no errors and declFiles generated did not match number of js files generated");
                 }
 
-                let declInputFiles: { unitName: string; content: string }[] = [];
-                let declOtherFiles: { unitName: string; content: string }[] = [];
+                const declInputFiles: { unitName: string; content: string }[] = [];
+                const declOtherFiles: { unitName: string; content: string }[] = [];
                 let declResult: Harness.Compiler.CompilerResult;
 
                 // if the .d.ts is non-empty, confirm it compiles correctly as well
@@ -1170,18 +1170,18 @@ namespace Harness {
                         dtsFiles.push(file);
                     }
                     else if (isTS(file.unitName)) {
-                        let declFile = findResultCodeFile(file.unitName);
+                        const declFile = findResultCodeFile(file.unitName);
                         if (!findUnit(declFile.fileName, declInputFiles) && !findUnit(declFile.fileName, declOtherFiles)) {
                             dtsFiles.push({ unitName: declFile.fileName, content: declFile.code });
                         }
                     }
 
                     function findResultCodeFile(fileName: string) {
-                        let sourceFile = result.program.getSourceFile(fileName);
+                        const sourceFile = result.program.getSourceFile(fileName);
                         assert(sourceFile, "Program has no source file with name '" + fileName + "'");
                         // Is this file going to be emitted separately
                         let sourceFileName: string;
-                        let outFile = options.outFile || options.out;
+                        const outFile = options.outFile || options.out;
                         if (ts.isExternalModule(sourceFile) || !outFile) {
                             if (options.outDir) {
                                 let sourceFilePath = ts.getNormalizedAbsolutePath(sourceFile.fileName, result.currentDirectoryForProgram);
@@ -1197,7 +1197,7 @@ namespace Harness {
                             sourceFileName = outFile;
                         }
 
-                        let dTsFileName = ts.removeFileExtension(sourceFileName) + ".d.ts";
+                        const dTsFileName = ts.removeFileExtension(sourceFileName) + ".d.ts";
 
                         return ts.forEach(result.declFilesCode, declFile => declFile.fileName === dTsFileName ? declFile : undefined);
                     }
@@ -1222,7 +1222,7 @@ namespace Harness {
             let errorOutput = "";
             ts.forEach(diagnostics, diagnostic => {
                 if (diagnostic.file) {
-                    let lineAndCharacter = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                    const lineAndCharacter = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
                     errorOutput += diagnostic.file.fileName + "(" + (lineAndCharacter.line + 1) + "," + (lineAndCharacter.character + 1) + "): ";
                 }
 
@@ -1234,14 +1234,14 @@ namespace Harness {
 
         export function getErrorBaseline(inputFiles: { unitName: string; content: string }[], diagnostics: ts.Diagnostic[]) {
             diagnostics.sort(ts.compareDiagnostics);
-            let outputLines: string[] = [];
+            const outputLines: string[] = [];
             // Count up all errors that were found in files other than lib.d.ts so we don't miss any
             let totalErrorsReportedInNonLibraryFiles = 0;
 
             function outputErrorText(error: ts.Diagnostic) {
-                let message = ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine());
+                const message = ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine());
 
-                let errLines = RunnerBase.removeFullPaths(message)
+                const errLines = RunnerBase.removeFullPaths(message)
                     .split("\n")
                     .map(s => s.length > 0 && s.charAt(s.length - 1) === "\r" ? s.substr(0, s.length - 1) : s)
                     .filter(s => s.length > 0)
@@ -1259,14 +1259,14 @@ namespace Harness {
             }
 
             // Report global errors
-            let globalErrors = diagnostics.filter(err => !err.file);
+            const globalErrors = diagnostics.filter(err => !err.file);
             globalErrors.forEach(outputErrorText);
 
             // 'merge' the lines of each input file with any errors associated with it
             inputFiles.filter(f => f.content !== undefined).forEach(inputFile => {
                 // Filter down to the errors in the file
-                let fileErrors = diagnostics.filter(e => {
-                    let errFn = e.file;
+                const fileErrors = diagnostics.filter(e => {
+                    const errFn = e.file;
                     return errFn && errFn.fileName === inputFile.unitName;
                 });
 
@@ -1280,7 +1280,7 @@ namespace Harness {
                 // Note: IE JS engine incorrectly handles consecutive delimiters here when using RegExp split, so
                 // we have to string-based splitting instead and try to figure out the delimiting chars
 
-                let lineStarts = ts.computeLineStarts(inputFile.content);
+                const lineStarts = ts.computeLineStarts(inputFile.content);
                 let lines = inputFile.content.split("\n");
                 if (lines.length === 1) {
                     lines = lines[0].split("\r");
@@ -1291,7 +1291,7 @@ namespace Harness {
                         line = line.substr(0, line.length - 1);
                     }
 
-                    let thisLineStart = lineStarts[lineIndex];
+                    const thisLineStart = lineStarts[lineIndex];
                     let nextLineStart: number;
                     // On the last line of the file, fake the next line start number so that we handle errors on the last character of the file correctly
                     if (lineIndex === lines.length - 1) {
@@ -1304,14 +1304,14 @@ namespace Harness {
                     outputLines.push("    " + line);
                     fileErrors.forEach(err => {
                         // Does any error start or continue on to this line? Emit squiggles
-                        let end = ts.textSpanEnd(err);
+                        const end = ts.textSpanEnd(err);
                         if ((end >= thisLineStart) && ((err.start < nextLineStart) || (lineIndex === lines.length - 1))) {
                             // How many characters from the start of this line the error starts at (could be positive or negative)
-                            let relativeOffset = err.start - thisLineStart;
+                            const relativeOffset = err.start - thisLineStart;
                             // How many characters of the error are on this line (might be longer than this line in reality)
-                            let length = (end - err.start) - Math.max(0, thisLineStart - err.start);
+                            const length = (end - err.start) - Math.max(0, thisLineStart - err.start);
                             // Calculate the start of the squiggle
-                            let squiggleStart = Math.max(0, relativeOffset);
+                            const squiggleStart = Math.max(0, relativeOffset);
                             // TODO/REVIEW: this doesn't work quite right in the browser if a multi file test has files whose names are just the right length relative to one another
                             outputLines.push("    " + line.substr(0, squiggleStart).replace(/[^\s]/g, " ") + new Array(Math.min(length, line.length - squiggleStart) + 1).join("~"));
 
@@ -1331,11 +1331,11 @@ namespace Harness {
                 assert.equal(markedErrorCount, fileErrors.length, "count of errors in " + inputFile.unitName);
             });
 
-            let numLibraryDiagnostics = ts.countWhere(diagnostics, diagnostic => {
+            const numLibraryDiagnostics = ts.countWhere(diagnostics, diagnostic => {
                 return diagnostic.file && (isLibraryFile(diagnostic.file.fileName) || isBuiltFile(diagnostic.file.fileName));
             });
 
-            let numTest262HarnessDiagnostics = ts.countWhere(diagnostics, diagnostic => {
+            const numTest262HarnessDiagnostics = ts.countWhere(diagnostics, diagnostic => {
                 // Count an error generated from tests262-harness folder.This should only apply for test262
                 return diagnostic.file && diagnostic.file.fileName.indexOf("test262-harness") >= 0;
             });
@@ -1353,7 +1353,7 @@ namespace Harness {
 
             // Emit them
             let result = "";
-            for (let outputFile of outputFiles) {
+            for (const outputFile of outputFiles) {
                 // Some extra spacing if this isn't the first file
                 if (result.length) {
                     result += "\r\n\r\n";
@@ -1368,7 +1368,7 @@ namespace Harness {
             return result;
 
             function cleanName(fn: string) {
-                let lastSlash = ts.normalizeSlashes(fn).lastIndexOf("/");
+                const lastSlash = ts.normalizeSlashes(fn).lastIndexOf("/");
                 return fn.substr(lastSlash + 1).toLowerCase();
             }
         }
@@ -1477,10 +1477,10 @@ namespace Harness {
         }
 
         // Regex for parsing options in the format "@Alpha: Value of any sort"
-        let optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm;  // multiple matches on multiple lines
+        const optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm;  // multiple matches on multiple lines
 
         function extractCompilerSettings(content: string): CompilerSettings {
-            let opts: CompilerSettings = {};
+            const opts: CompilerSettings = {};
 
             let match: RegExpExecArray;
             while ((match = optionRegex.exec(content)) != null) {
@@ -1492,12 +1492,12 @@ namespace Harness {
 
         /** Given a test file containing // @FileName directives, return an array of named units of code to be added to an existing compiler instance */
         export function makeUnitsFromTest(code: string, fileName: string): { settings: CompilerSettings; testUnitData: TestUnitData[]; } {
-            let settings = extractCompilerSettings(code);
+            const settings = extractCompilerSettings(code);
 
             // List of all the subfiles we've parsed out
-            let testUnitData: TestUnitData[] = [];
+            const testUnitData: TestUnitData[] = [];
 
-            let lines = Utils.splitContentByNewlines(code);
+            const lines = Utils.splitContentByNewlines(code);
 
             // Stuff related to the subfile we're parsing
             let currentFileContent: string = null;
@@ -1506,12 +1506,12 @@ namespace Harness {
             let refs: string[] = [];
 
             for (let i = 0; i < lines.length; i++) {
-                let line = lines[i];
-                let testMetaData = optionRegex.exec(line);
+                const line = lines[i];
+                const testMetaData = optionRegex.exec(line);
                 if (testMetaData) {
                     // Comment line, check for global/file @options and record them
                     optionRegex.lastIndex = 0;
-                    let metaDataName = testMetaData[1].toLowerCase();
+                    const metaDataName = testMetaData[1].toLowerCase();
                     if (metaDataName === "filename") {
                         currentFileOptions[testMetaData[1]] = testMetaData[2];
                     }
@@ -1522,7 +1522,7 @@ namespace Harness {
                     // New metadata statement after having collected some code to go with the previous metadata
                     if (currentFileName) {
                         // Store result file
-                        let newTestFile = {
+                        const newTestFile = {
                                 content: currentFileContent,
                                 name: currentFileName,
                                 fileOptions: currentFileOptions,
@@ -1560,7 +1560,7 @@ namespace Harness {
             currentFileName = testUnitData.length > 0 || currentFileName ? currentFileName : Path.getFileName(fileName);
 
             // EOF, push whatever remains
-            let newTestFile2 = {
+            const newTestFile2 = {
                 content: currentFileContent || "",
                 name: currentFileName,
                 fileOptions: currentFileOptions,
@@ -1608,7 +1608,7 @@ namespace Harness {
             }
         }
 
-        let fileCache: { [idx: string]: boolean } = {};
+        const fileCache: { [idx: string]: boolean } = {};
         function generateActual(actualFileName: string, generateContent: () => string): string {
             // For now this is written using TypeScript, because sys is not available when running old test cases.
             // But we need to move to sys once we have
@@ -1619,7 +1619,7 @@ namespace Harness {
                     return;
                 }
 
-                let parentDirectory = IO.directoryName(dirName);
+                const parentDirectory = IO.directoryName(dirName);
                 if (parentDirectory != "") {
                     createDirectoryStructure(parentDirectory);
                 }
@@ -1635,7 +1635,7 @@ namespace Harness {
                 IO.deleteFile(actualFileName);
             }
 
-            let actual = generateContent();
+            const actual = generateContent();
 
             if (actual === undefined) {
                 throw new Error("The generated content was \"undefined\". Return \"null\" if no baselining is required.\"");
@@ -1658,7 +1658,7 @@ namespace Harness {
                 return;
             }
 
-            let refFileName = referencePath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
+            const refFileName = referencePath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
 
             if (actual === null) {
                 actual = "<no content>";
@@ -1673,10 +1673,10 @@ namespace Harness {
         }
 
         function writeComparison(expected: string, actual: string, relativeFileName: string, actualFileName: string, descriptionForDescribe: string) {
-            let encoded_actual =  Utils.encodeString(actual);
+            const encoded_actual =  Utils.encodeString(actual);
             if (expected != encoded_actual) {
                 // Overwrite & issue error
-                let errMsg = "The baseline file " + relativeFileName + " has changed.";
+                const errMsg = "The baseline file " + relativeFileName + " has changed.";
                 throw new Error(errMsg);
             }
         }
@@ -1689,17 +1689,17 @@ namespace Harness {
             opts?: BaselineOptions): void {
 
             let actual = <string>undefined;
-            let actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
+            const actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
 
             if (runImmediately) {
                 actual = generateActual(actualFileName, generateContent);
-                let comparison = compareToBaseline(actual, relativeFileName, opts);
+                const comparison = compareToBaseline(actual, relativeFileName, opts);
                 writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName, descriptionForDescribe);
             }
             else {
                 actual = generateActual(actualFileName, generateContent);
 
-                let comparison = compareToBaseline(actual, relativeFileName, opts);
+                const comparison = compareToBaseline(actual, relativeFileName, opts);
                 writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName, descriptionForDescribe);
             }
         }
@@ -1714,7 +1714,7 @@ namespace Harness {
     }
 
     export function getDefaultLibraryFile(io: Harness.IO): { unitName: string, content: string } {
-        let libFile = Harness.userSpecifiedRoot + Harness.libFolder + "lib.d.ts";
+        const libFile = Harness.userSpecifiedRoot + Harness.libFolder + "lib.d.ts";
         return {
             unitName: libFile,
             content: io.readFile(libFile)
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index df5efccdcb5..50dbef5a410 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -26,9 +26,9 @@ namespace Harness.LanguageService {
 
         public editContent(start: number, end: number, newText: string): void {
             // Apply edits
-            let prefix = this.content.substring(0, start);
-            let middle = newText;
-            let suffix = this.content.substring(end);
+            const prefix = this.content.substring(0, start);
+            const middle = newText;
+            const suffix = this.content.substring(end);
             this.setContent(prefix + middle + suffix);
 
             // Store edit range + new length of script
@@ -48,10 +48,10 @@ namespace Harness.LanguageService {
                 return ts.unchangedTextChangeRange;
             }
 
-            let initialEditRangeIndex = this.editRanges.length - (this.version - startVersion);
-            let lastEditRangeIndex = this.editRanges.length - (this.version - endVersion);
+            const initialEditRangeIndex = this.editRanges.length - (this.version - startVersion);
+            const lastEditRangeIndex = this.editRanges.length - (this.version - endVersion);
 
-            let entries = this.editRanges.slice(initialEditRangeIndex, lastEditRangeIndex);
+            const entries = this.editRanges.slice(initialEditRangeIndex, lastEditRangeIndex);
             return ts.collapseTextChangeRangesAcrossMultipleVersions(entries.map(e => e.textChangeRange));
         }
     }
@@ -74,7 +74,7 @@ namespace Harness.LanguageService {
         }
 
         public getChangeRange(oldScript: ts.IScriptSnapshot): ts.TextChangeRange {
-            let oldShim = <ScriptSnapshot>oldScript;
+            const oldShim = <ScriptSnapshot>oldScript;
             return this.scriptInfo.getTextChangeRangeBetweenVersions(oldShim.version, this.version);
         }
     }
@@ -92,9 +92,9 @@ namespace Harness.LanguageService {
         }
 
         public getChangeRange(oldScript: ts.ScriptSnapshotShim): string {
-            let oldShim = <ScriptSnapshotProxy>oldScript;
+            const oldShim = <ScriptSnapshotProxy>oldScript;
 
-            let range = this.scriptSnapshot.getChangeRange(oldShim.scriptSnapshot);
+            const range = this.scriptSnapshot.getChangeRange(oldShim.scriptSnapshot);
             if (range === undefined) {
                 return undefined;
             }
@@ -130,7 +130,7 @@ namespace Harness.LanguageService {
         }
 
         public getFilenames(): string[] {
-            let fileNames: string[] = [];
+            const fileNames: string[] = [];
             ts.forEachKey(this.fileNameToScript, (fileName) => { fileNames.push(fileName); });
             return fileNames;
         }
@@ -144,7 +144,7 @@ namespace Harness.LanguageService {
         }
 
         public editScript(fileName: string, start: number, end: number, newText: string) {
-            let script = this.getScriptInfo(fileName);
+            const script = this.getScriptInfo(fileName);
             if (script !== undefined) {
                 script.editContent(start, end, newText);
                 return;
@@ -161,7 +161,7 @@ namespace Harness.LanguageService {
           * @param col 0 based index
           */
         public positionToLineAndCharacter(fileName: string, position: number): ts.LineAndCharacter {
-            let script: ScriptInfo = this.fileNameToScript[fileName];
+            const script: ScriptInfo = this.fileNameToScript[fileName];
             assert.isNotNull(script);
 
             return ts.computeLineAndCharacterOfPosition(script.lineMap, position);
@@ -176,11 +176,11 @@ namespace Harness.LanguageService {
         getDefaultLibFileName(): string { return ""; }
         getScriptFileNames(): string[] { return this.getFilenames(); }
         getScriptSnapshot(fileName: string): ts.IScriptSnapshot {
-            let script = this.getScriptInfo(fileName);
+            const script = this.getScriptInfo(fileName);
             return script ? new ScriptSnapshot(script) : undefined;
         }
         getScriptVersion(fileName: string): string {
-            let script = this.getScriptInfo(fileName);
+            const script = this.getScriptInfo(fileName);
             return script ? script.version.toString() : undefined;
         }
 
@@ -211,20 +211,20 @@ namespace Harness.LanguageService {
             this.nativeHost = new NativeLanguageServiceHost(cancellationToken, options);
 
             if (preprocessToResolve) {
-                let compilerOptions = this.nativeHost.getCompilationSettings();
-                let moduleResolutionHost: ts.ModuleResolutionHost = {
+                const compilerOptions = this.nativeHost.getCompilationSettings();
+                const moduleResolutionHost: ts.ModuleResolutionHost = {
                     fileExists: fileName => this.getScriptInfo(fileName) !== undefined,
                     readFile: fileName => {
-                        let scriptInfo = this.getScriptInfo(fileName);
+                        const scriptInfo = this.getScriptInfo(fileName);
                         return scriptInfo && scriptInfo.content;
                     }
                 };
                 this.getModuleResolutionsForFile = (fileName) => {
-                    let scriptInfo = this.getScriptInfo(fileName);
-                    let preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
-                    let imports: ts.Map<string> = {};
-                    for (let module of preprocessInfo.importedFiles) {
-                        let resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
+                    const scriptInfo = this.getScriptInfo(fileName);
+                    const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
+                    const imports: ts.Map<string> = {};
+                    for (const module of preprocessInfo.importedFiles) {
+                        const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
                         if (resolutionInfo.resolvedModule) {
                             imports[module.fileName] = resolutionInfo.resolvedModule.resolvedFileName;
                         }
@@ -246,7 +246,7 @@ namespace Harness.LanguageService {
         getDefaultLibFileName(): string { return this.nativeHost.getDefaultLibFileName(); }
         getScriptFileNames(): string { return JSON.stringify(this.nativeHost.getScriptFileNames()); }
         getScriptSnapshot(fileName: string): ts.ScriptSnapshotShim {
-            let nativeScriptSnapshot = this.nativeHost.getScriptSnapshot(fileName);
+            const nativeScriptSnapshot = this.nativeHost.getScriptSnapshot(fileName);
             return nativeScriptSnapshot && new ScriptSnapshotProxy(nativeScriptSnapshot);
         }
         getScriptVersion(fileName: string): string { return this.nativeHost.getScriptVersion(fileName); }
@@ -257,7 +257,7 @@ namespace Harness.LanguageService {
         }
         fileExists(fileName: string) { return this.getScriptInfo(fileName) !== undefined; }
         readFile(fileName: string) {
-            let snapshot = this.nativeHost.getScriptSnapshot(fileName);
+            const snapshot = this.nativeHost.getScriptSnapshot(fileName);
             return snapshot && snapshot.getText(0, snapshot.getLength());
         }
         log(s: string): void { this.nativeHost.log(s); }
@@ -272,13 +272,13 @@ namespace Harness.LanguageService {
             throw new Error("NYI");
         }
         getClassificationsForLine(text: string, lexState: ts.EndOfLineState, classifyKeywordsInGenerics?: boolean): ts.ClassificationResult {
-            let result = this.shim.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics).split("\n");
-            let entries: ts.ClassificationInfo[] = [];
+            const result = this.shim.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics).split("\n");
+            const entries: ts.ClassificationInfo[] = [];
             let i = 0;
             let position = 0;
 
             for (; i < result.length - 1; i += 2) {
-                let t = entries[i / 2] = {
+                const t = entries[i / 2] = {
                     length: parseInt(result[i]),
                     classification: parseInt(result[i + 1])
                 };
@@ -286,7 +286,7 @@ namespace Harness.LanguageService {
                 assert.isTrue(t.length > 0, "Result length should be greater than 0, got :" + t.length);
                 position += t.length;
             }
-            let finalLexState = parseInt(result[result.length - 1]);
+            const finalLexState = parseInt(result[result.length - 1]);
 
             assert.equal(position, text.length, "Expected cumulative length of all entries to match the length of the source. expected: " + text.length + ", but got: " + position);
 
@@ -298,7 +298,7 @@ namespace Harness.LanguageService {
     }
 
     function unwrapJSONCallResult(result: string): any {
-        let parsedResult = JSON.parse(result);
+        const parsedResult = JSON.parse(result);
         if (parsedResult.error) {
             throw new Error("Language Service Shim Error: " + JSON.stringify(parsedResult.error));
         }
@@ -312,7 +312,7 @@ namespace Harness.LanguageService {
         constructor(private shim: ts.LanguageServiceShim) {
         }
         private unwrappJSONCallResult(result: string): any {
-            let parsedResult = JSON.parse(result);
+            const parsedResult = JSON.parse(result);
             if (parsedResult.error) {
                 throw new Error("Language Service Shim Error: " + JSON.stringify(parsedResult.error));
             }
@@ -443,10 +443,10 @@ namespace Harness.LanguageService {
                 isLibFile: boolean;
             };
 
-            let coreServicesShim = this.factory.createCoreServicesShim(this.host);
+            const coreServicesShim = this.factory.createCoreServicesShim(this.host);
             shimResult = unwrapJSONCallResult(coreServicesShim.getPreProcessedFileInfo(fileName, ts.ScriptSnapshot.fromString(fileContents)));
 
-            let convertResult: ts.PreProcessedFileInfo = {
+            const convertResult: ts.PreProcessedFileInfo = {
                 referencedFiles: [],
                 importedFiles: [],
                 ambientExternalModules: [],
@@ -530,7 +530,7 @@ namespace Harness.LanguageService {
                 fileName = Harness.Compiler.defaultLibFileName;
             }
 
-            let snapshot = this.host.getScriptSnapshot(fileName);
+            const snapshot = this.host.getScriptSnapshot(fileName);
             return snapshot && snapshot.getText(0, snapshot.getLength());
         }
 
@@ -612,13 +612,13 @@ namespace Harness.LanguageService {
         private client: ts.server.SessionClient;
         constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
             // This is the main host that tests use to direct tests
-            let clientHost = new SessionClientHost(cancellationToken, options);
-            let client = new ts.server.SessionClient(clientHost);
+            const clientHost = new SessionClientHost(cancellationToken, options);
+            const client = new ts.server.SessionClient(clientHost);
 
             // This host is just a proxy for the clientHost, it uses the client
             // host to answer server queries about files on disk
-            let serverHost = new SessionServerHost(clientHost);
-            let server = new ts.server.Session(serverHost,
+            const serverHost = new SessionServerHost(clientHost);
+            const server = new ts.server.Session(serverHost,
                 Buffer ? Buffer.byteLength : (string: string, encoding?: string) => string.length,
                 process.hrtime, serverHost);
 
diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts
index d60756edf19..bf56f1aa3ea 100644
--- a/src/harness/loggedIO.ts
+++ b/src/harness/loggedIO.ts
@@ -89,7 +89,7 @@ namespace Playback {
 
     function memoize<T>(func: (s: string) => T): Memoized<T> {
         let lookup: { [s: string]: T } = {};
-        let run: Memoized<T> = <Memoized<T>>((s: string) => {
+        const run: Memoized<T> = <Memoized<T>>((s: string) => {
             if (lookup.hasOwnProperty(s)) return lookup[s];
             return lookup[s] = func(s);
         });
@@ -159,7 +159,7 @@ namespace Playback {
         wrapper.endRecord = () => {
             if (recordLog !== undefined) {
                 let i = 0;
-                let fn = () => recordLogFileNameBase + i + ".json";
+                const fn = () => recordLogFileNameBase + i + ".json";
                 while (underlying.fileExists(fn())) i++;
                 underlying.writeFile(fn(), JSON.stringify(recordLog));
                 recordLog = undefined;
@@ -209,8 +209,8 @@ namespace Playback {
 
         wrapper.readFile = recordReplay(wrapper.readFile, underlying)(
             path => {
-                let result = underlying.readFile(path);
-                let logEntry = { path, codepage: 0, result: { contents: result, codepage: 0 } };
+                const result = underlying.readFile(path);
+                const logEntry = { path, codepage: 0, result: { contents: result, codepage: 0 } };
                 recordLog.filesRead.push(logEntry);
                 return result;
             },
@@ -218,8 +218,8 @@ namespace Playback {
 
         wrapper.readDirectory = recordReplay(wrapper.readDirectory, underlying)(
             (path, extension, exclude) => {
-                let result = (<ts.System>underlying).readDirectory(path, extension, exclude);
-                let logEntry = { path, extension, exclude, result };
+                const result = (<ts.System>underlying).readDirectory(path, extension, exclude);
+                const logEntry = { path, extension, exclude, result };
                 recordLog.directoriesRead.push(logEntry);
                 return result;
             },
@@ -263,10 +263,10 @@ namespace Playback {
     }
 
     function findResultByFields<T>(logArray: { result?: T }[], expectedFields: {}, defaultValue?: T): T {
-        let predicate = (entry: { result?: T }) => {
+        const predicate = (entry: { result?: T }) => {
             return Object.getOwnPropertyNames(expectedFields).every((name) => (<any>entry)[name] === (<any>expectedFields)[name]);
         };
-        let results = logArray.filter(entry => predicate(entry));
+        const results = logArray.filter(entry => predicate(entry));
         if (results.length === 0) {
             if (defaultValue !== undefined) {
                 return defaultValue;
@@ -279,7 +279,7 @@ namespace Playback {
     }
 
     function findResultByPath<T>(wrapper: { resolvePath(s: string): string }, logArray: { path: string; result?: T }[], expectedPath: string, defaultValue?: T): T {
-        let normalizedName = ts.normalizePath(expectedPath).toLowerCase();
+        const normalizedName = ts.normalizePath(expectedPath).toLowerCase();
         // Try to find the result through normal fileName
         for (let i = 0; i < logArray.length; i++) {
             if (ts.normalizeSlashes(logArray[i].path).toLowerCase() === normalizedName) {
@@ -288,7 +288,7 @@ namespace Playback {
         }
         // Fallback, try to resolve the target paths as well
         if (replayLog.pathsResolved.length > 0) {
-            let normalizedResolvedName = wrapper.resolvePath(expectedPath).toLowerCase();
+            const normalizedResolvedName = wrapper.resolvePath(expectedPath).toLowerCase();
             for (let i = 0; i < logArray.length; i++) {
                 if (wrapper.resolvePath(logArray[i].path).toLowerCase() === normalizedResolvedName) {
                     return logArray[i].result;
@@ -305,9 +305,9 @@ namespace Playback {
         }
     }
 
-    let pathEquivCache: any = {};
+    const pathEquivCache: any = {};
     function pathsAreEquivalent(left: string, right: string, wrapper: { resolvePath(s: string): string }) {
-        let key = left + "-~~-" + right;
+        const key = left + "-~~-" + right;
         function areSame(a: string, b: string) {
             return ts.normalizeSlashes(a).toLowerCase() === ts.normalizeSlashes(b).toLowerCase();
         }
@@ -329,7 +329,7 @@ namespace Playback {
     }
 
     export function wrapIO(underlying: Harness.IO): PlaybackIO {
-        let wrapper: PlaybackIO = <any>{};
+        const wrapper: PlaybackIO = <any>{};
         initWrapper(wrapper, underlying);
 
         wrapper.directoryName = (path): string => { throw new Error("NotSupported"); };
@@ -342,7 +342,7 @@ namespace Playback {
     }
 
     export function wrapSystem(underlying: ts.System): PlaybackSystem {
-        let wrapper: PlaybackSystem = <any>{};
+        const wrapper: PlaybackSystem = <any>{};
         initWrapper(wrapper, underlying);
         return wrapper;
     }
diff --git a/src/harness/projectsRunner.ts b/src/harness/projectsRunner.ts
index 7b8db662406..86a2e8b90d8 100644
--- a/src/harness/projectsRunner.ts
+++ b/src/harness/projectsRunner.ts
@@ -39,7 +39,7 @@ interface BatchCompileProjectTestCaseResult extends CompileProjectFilesResult {
 class ProjectRunner extends RunnerBase {
     public initializeTests() {
         if (this.tests.length === 0) {
-            let testFiles = this.enumerateFiles("tests/cases/project", /\.json$/, { recursive: true });
+            const testFiles = this.enumerateFiles("tests/cases/project", /\.json$/, { recursive: true });
             testFiles.forEach(fn => {
                 fn = fn.replace(/\\/g, "/");
                 this.runProjectTestCase(fn);
@@ -93,7 +93,7 @@ class ProjectRunner extends RunnerBase {
         function cleanProjectUrl(url: string) {
             let diskProjectPath = ts.normalizeSlashes(Harness.IO.resolvePath(testCase.projectRoot));
             let projectRootUrl = "file:///" + diskProjectPath;
-            let normalizedProjectRoot = ts.normalizeSlashes(testCase.projectRoot);
+            const normalizedProjectRoot = ts.normalizeSlashes(testCase.projectRoot);
             diskProjectPath = diskProjectPath.substr(0, diskProjectPath.lastIndexOf(normalizedProjectRoot));
             projectRootUrl = projectRootUrl.substr(0, projectRootUrl.lastIndexOf(normalizedProjectRoot));
             if (url && url.length) {
@@ -123,12 +123,12 @@ class ProjectRunner extends RunnerBase {
             writeFile: (fileName: string, data: string, writeByteOrderMark: boolean) => void,
             compilerOptions: ts.CompilerOptions): CompileProjectFilesResult {
 
-            let program = ts.createProgram(getInputFiles(), compilerOptions, createCompilerHost());
+            const program = ts.createProgram(getInputFiles(), compilerOptions, createCompilerHost());
             let errors = ts.getPreEmitDiagnostics(program);
 
-            let emitResult = program.emit();
+            const emitResult = program.emit();
             errors = ts.concatenate(errors, emitResult.diagnostics);
-            let sourceMapData = emitResult.sourceMaps;
+            const sourceMapData = emitResult.sourceMaps;
 
             // Clean up source map data that will be used in baselining
             if (sourceMapData) {
@@ -159,7 +159,7 @@ class ProjectRunner extends RunnerBase {
                     sourceFile = languageVersion === ts.ScriptTarget.ES6 ? Harness.Compiler.defaultES6LibSourceFile : Harness.Compiler.defaultLibSourceFile;
                 }
                 else {
-                    let text = getSourceFileText(fileName);
+                    const text = getSourceFileText(fileName);
                     if (text !== undefined) {
                         sourceFile = Harness.Compiler.createSourceFileAndAssertInvariants(fileName, text, languageVersion);
                     }
@@ -186,7 +186,7 @@ class ProjectRunner extends RunnerBase {
         function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult {
             let nonSubfolderDiskFiles = 0;
 
-            let outputFiles: BatchCompileProjectTestCaseEmittedFile[] = [];
+            const outputFiles: BatchCompileProjectTestCaseEmittedFile[] = [];
             let inputFiles = testCase.inputFiles;
             let compilerOptions = createCompilerOptions();
 
@@ -201,7 +201,7 @@ class ProjectRunner extends RunnerBase {
             }
 
             if (configFileName) {
-                let result = ts.readConfigFile(configFileName, getSourceFileText);
+                const result = ts.readConfigFile(configFileName, getSourceFileText);
                 if (result.error) {
                     return {
                         moduleKind,
@@ -209,8 +209,8 @@ class ProjectRunner extends RunnerBase {
                     };
                 }
 
-                let configObject = result.config;
-                let configParseResult = ts.parseJsonConfigFileContent(configObject, { readDirectory }, ts.getDirectoryPath(configFileName), compilerOptions);
+                const configObject = result.config;
+                const configParseResult = ts.parseJsonConfigFileContent(configObject, { readDirectory }, ts.getDirectoryPath(configFileName), compilerOptions);
                 if (configParseResult.errors.length > 0) {
                     return {
                         moduleKind,
@@ -221,7 +221,7 @@ class ProjectRunner extends RunnerBase {
                 compilerOptions = configParseResult.options;
             }
 
-            let projectCompilerResult = compileProjectFiles(moduleKind, () => inputFiles, getSourceFileText, writeFile, compilerOptions);
+            const projectCompilerResult = compileProjectFiles(moduleKind, () => inputFiles, getSourceFileText, writeFile, compilerOptions);
             return {
                 moduleKind,
                 program: projectCompilerResult.program,
@@ -233,24 +233,24 @@ class ProjectRunner extends RunnerBase {
 
             function createCompilerOptions() {
                 // Set the special options that depend on other testcase options
-                let compilerOptions: ts.CompilerOptions = {
+                const compilerOptions: ts.CompilerOptions = {
                     mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? Harness.IO.resolvePath(testCase.mapRoot) : testCase.mapRoot,
                     sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? Harness.IO.resolvePath(testCase.sourceRoot) : testCase.sourceRoot,
                     module: moduleKind,
                     moduleResolution: ts.ModuleResolutionKind.Classic, // currently all tests use classic module resolution kind, this will change in the future 
                 };
                 // Set the values specified using json
-                let optionNameMap: ts.Map<ts.CommandLineOption> = {};
+                const optionNameMap: ts.Map<ts.CommandLineOption> = {};
                 ts.forEach(ts.optionDeclarations, option => {
                     optionNameMap[option.name] = option;
                 });
-                for (let name in testCase) {
+                for (const name in testCase) {
                     if (name !== "mapRoot" && name !== "sourceRoot" && ts.hasProperty(optionNameMap, name)) {
-                        let option = optionNameMap[name];
-                        let optType = option.type;
+                        const option = optionNameMap[name];
+                        const optType = option.type;
                         let value = <any>testCase[name];
                         if (typeof optType !== "string") {
-                            let key = value.toLowerCase();
+                            const key = value.toLowerCase();
                             if (ts.hasProperty(optType, key)) {
                                 value = optType[key];
                             }
@@ -269,8 +269,8 @@ class ProjectRunner extends RunnerBase {
             }
 
             function readDirectory(rootDir: string, extension: string, exclude: string[]): string[] {
-                let harnessReadDirectoryResult = Harness.IO.readDirectory(getFileNameInTheProjectTest(rootDir), extension, exclude);
-                let result: string[] = [];
+                const harnessReadDirectoryResult = Harness.IO.readDirectory(getFileNameInTheProjectTest(rootDir), extension, exclude);
+                const result: string[] = [];
                 for (let i = 0; i < harnessReadDirectoryResult.length; i++) {
                     result[i] = ts.getRelativePathToDirectoryOrUrl(testCase.projectRoot, harnessReadDirectoryResult[i],
                         getCurrentDirectory(), Harness.Compiler.getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
@@ -296,11 +296,11 @@ class ProjectRunner extends RunnerBase {
             function writeFile(fileName: string, data: string, writeByteOrderMark: boolean) {
                 // convert file name to rooted name
                 // if filename is not rooted - concat it with project root and then expand project root relative to current directory
-                let diskFileName = ts.isRootedDiskPath(fileName)
+                const diskFileName = ts.isRootedDiskPath(fileName)
                     ? fileName
                     : Harness.IO.resolvePath(ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(fileName));
 
-                let currentDirectory = getCurrentDirectory();
+                const currentDirectory = getCurrentDirectory();
                 // compute file name relative to current directory (expanded project root)
                 let diskRelativeName = ts.getRelativePathToDirectoryOrUrl(currentDirectory, diskFileName, currentDirectory, Harness.Compiler.getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
                 if (ts.isRootedDiskPath(diskRelativeName) || diskRelativeName.substr(0, 3) === "../") {
@@ -314,14 +314,14 @@ class ProjectRunner extends RunnerBase {
 
                 if (Harness.Compiler.isJS(fileName)) {
                     // Make sure if there is URl we have it cleaned up
-                    let indexOfSourceMapUrl = data.lastIndexOf("//# sourceMappingURL=");
+                    const indexOfSourceMapUrl = data.lastIndexOf("//# sourceMappingURL=");
                     if (indexOfSourceMapUrl !== -1) {
                         data = data.substring(0, indexOfSourceMapUrl + 21) + cleanProjectUrl(data.substring(indexOfSourceMapUrl + 21));
                     }
                 }
                 else if (Harness.Compiler.isJSMap(fileName)) {
                     // Make sure sources list is cleaned
-                    let sourceMapData = JSON.parse(data);
+                    const sourceMapData = JSON.parse(data);
                     for (let i = 0; i < sourceMapData.sources.length; i++) {
                         sourceMapData.sources[i] = cleanProjectUrl(sourceMapData.sources[i]);
                     }
@@ -329,7 +329,7 @@ class ProjectRunner extends RunnerBase {
                     data = JSON.stringify(sourceMapData);
                 }
 
-                let outputFilePath = getProjectOutputFolder(diskRelativeName, moduleKind);
+                const outputFilePath = getProjectOutputFolder(diskRelativeName, moduleKind);
                 // Actual writing of file as in tc.ts
                 function ensureDirectoryStructure(directoryname: string) {
                     if (directoryname) {
@@ -347,11 +347,11 @@ class ProjectRunner extends RunnerBase {
         }
 
         function compileCompileDTsFiles(compilerResult: BatchCompileProjectTestCaseResult) {
-            let allInputFiles: { emittedFileName: string; code: string; }[] = [];
+            const allInputFiles: { emittedFileName: string; code: string; }[] = [];
             if (!compilerResult.program) {
                 return;
             }
-            let compilerOptions = compilerResult.program.getCompilerOptions();
+            const compilerOptions = compilerResult.program.getCompilerOptions();
 
             ts.forEach(compilerResult.program.getSourceFiles(), sourceFile => {
                 if (Harness.Compiler.isDTS(sourceFile.fileName)) {
@@ -368,12 +368,12 @@ class ProjectRunner extends RunnerBase {
                         emitOutputFilePathWithoutExtension = ts.removeFileExtension(sourceFile.fileName);
                     }
 
-                    let outputDtsFileName = emitOutputFilePathWithoutExtension + ".d.ts";
+                    const outputDtsFileName = emitOutputFilePathWithoutExtension + ".d.ts";
                     allInputFiles.unshift(findOutpuDtsFile(outputDtsFileName));
                 }
                 else {
-                    let outputDtsFileName = ts.removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts";
-                    let outputDtsFile = findOutpuDtsFile(outputDtsFileName);
+                    const outputDtsFileName = ts.removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts";
+                    const outputDtsFile = findOutpuDtsFile(outputDtsFileName);
                     if (!ts.contains(allInputFiles, outputDtsFile)) {
                         allInputFiles.unshift(outputDtsFile);
                     }
@@ -407,7 +407,7 @@ class ProjectRunner extends RunnerBase {
         }
 
         function getErrorsBaseline(compilerResult: CompileProjectFilesResult) {
-            let inputFiles = compilerResult.program ? ts.map(ts.filter(compilerResult.program.getSourceFiles(),
+            const inputFiles = compilerResult.program ? ts.map(ts.filter(compilerResult.program.getSourceFiles(),
                 sourceFile => sourceFile.fileName !== "lib.d.ts"),
                 sourceFile => {
                     return { unitName: sourceFile.fileName, content: sourceFile.text };
@@ -416,7 +416,7 @@ class ProjectRunner extends RunnerBase {
             return Harness.Compiler.getErrorBaseline(inputFiles, compilerResult.errors);
         }
 
-        let name = "Compiling project for " + testCase.scenario + ": testcase " + testCaseFileName;
+        const name = "Compiling project for " + testCase.scenario + ": testcase " + testCaseFileName;
 
         describe("Projects tests", () => {
             describe(name, () => {
@@ -424,7 +424,7 @@ class ProjectRunner extends RunnerBase {
                     let compilerResult: BatchCompileProjectTestCaseResult;
 
                     function getCompilerResolutionInfo() {
-                        let resolutionInfo: ProjectRunnerTestCaseResolutionInfo & ts.CompilerOptions = JSON.parse(JSON.stringify(testCase));
+                        const resolutionInfo: ProjectRunnerTestCaseResolutionInfo & ts.CompilerOptions = JSON.parse(JSON.stringify(testCase));
                         resolutionInfo.resolvedInputFiles = ts.map(compilerResult.program.getSourceFiles(), inputFile => {
                             return ts.convertToRelativePath(inputFile.fileName, getCurrentDirectory(), path => Harness.Compiler.getCanonicalFileName(path));
                         });
@@ -485,7 +485,7 @@ class ProjectRunner extends RunnerBase {
 
                     it("Errors in generated Dts files for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                         if (!compilerResult.errors.length && testCase.declaration) {
-                            let dTsCompileResult = compileCompileDTsFiles(compilerResult);
+                            const dTsCompileResult = compileCompileDTsFiles(compilerResult);
                             if (dTsCompileResult && dTsCompileResult.errors.length) {
                                 Harness.Baseline.runBaseline("Errors in generated Dts files for (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".dts.errors.txt", () => {
                                     return getErrorsBaseline(dTsCompileResult);
diff --git a/src/harness/runner.ts b/src/harness/runner.ts
index 366355520a2..ec8e1105c2f 100644
--- a/src/harness/runner.ts
+++ b/src/harness/runner.ts
@@ -41,13 +41,13 @@ let testConfigFile =
     (Harness.IO.fileExists(testconfig) ? Harness.IO.readFile(testconfig) : "");
 
 if (testConfigFile !== "") {
-    let testConfig = JSON.parse(testConfigFile);
+    const testConfig = JSON.parse(testConfigFile);
     if (testConfig.light) {
         Harness.lightMode = true;
     }
 
     if (testConfig.test && testConfig.test.length > 0) {
-        for (let option of testConfig.test) {
+        for (const option of testConfig.test) {
             if (!option) {
                 continue;
             }
diff --git a/src/harness/runnerbase.ts b/src/harness/runnerbase.ts
index 7469325475a..a114e8c3201 100644
--- a/src/harness/runnerbase.ts
+++ b/src/harness/runnerbase.ts
@@ -25,14 +25,14 @@ abstract class RunnerBase {
         let fixedPath = path;
 
         // full paths either start with a drive letter or / for *nix, shouldn't have \ in the path at this point
-        let fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g;
-        let fullPathList = fixedPath.match(fullPath);
+        const fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g;
+        const fullPathList = fixedPath.match(fullPath);
         if (fullPathList) {
             fullPathList.forEach((match: string) => fixedPath = fixedPath.replace(match, Harness.Path.getFileName(match)));
         }
 
         // when running in the browser the 'full path' is the host name, shows up in error baselines
-        let localHost = /http:\/localhost:\d+/g;
+        const localHost = /http:\/localhost:\d+/g;
         fixedPath = fixedPath.replace(localHost, "");
         return fixedPath;
     }
diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts
index 19c989bcd6f..a350eda08f3 100644
--- a/src/harness/rwcRunner.ts
+++ b/src/harness/rwcRunner.ts
@@ -6,9 +6,9 @@
 
 namespace RWC {
     function runWithIOLog(ioLog: IOLog, fn: (oldIO: Harness.IO) => void) {
-        let oldIO = Harness.IO;
+        const oldIO = Harness.IO;
 
-        let wrappedIO = Playback.wrapIO(oldIO);
+        const wrappedIO = Playback.wrapIO(oldIO);
         wrappedIO.startReplayFromData(ioLog);
         Harness.IO = wrappedIO;
 
@@ -55,10 +55,10 @@ namespace RWC {
             });
 
             it("can compile", () => {
-                let harnessCompiler = Harness.Compiler.getCompiler();
+                const harnessCompiler = Harness.Compiler.getCompiler();
                 let opts: ts.ParsedCommandLine;
 
-                let ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
+                const ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
                 currentDirectory = ioLog.currentDirectory;
                 useCustomLibraryFile = ioLog.useCustomLibraryFile;
                 runWithIOLog(ioLog, () => {
@@ -75,26 +75,26 @@ namespace RWC {
 
                     let fileNames = opts.fileNames;
 
-                    let tsconfigFile = ts.forEach(ioLog.filesRead, f => isTsConfigFile(f) ? f : undefined);
+                    const tsconfigFile = ts.forEach(ioLog.filesRead, f => isTsConfigFile(f) ? f : undefined);
                     if (tsconfigFile) {
-                        let tsconfigFileContents = getHarnessCompilerInputUnit(tsconfigFile.path);
-                        let parsedTsconfigFileContents = ts.parseConfigFileTextToJson(tsconfigFile.path, tsconfigFileContents.content);
-                        let configParseResult = ts.parseJsonConfigFileContent(parsedTsconfigFileContents.config, Harness.IO, ts.getDirectoryPath(tsconfigFile.path));
+                        const tsconfigFileContents = getHarnessCompilerInputUnit(tsconfigFile.path);
+                        const parsedTsconfigFileContents = ts.parseConfigFileTextToJson(tsconfigFile.path, tsconfigFileContents.content);
+                        const configParseResult = ts.parseJsonConfigFileContent(parsedTsconfigFileContents.config, Harness.IO, ts.getDirectoryPath(tsconfigFile.path));
                         fileNames = configParseResult.fileNames;
                         opts.options = ts.extend(opts.options, configParseResult.options);
                     }
 
                     // Load the files
-                    for (let fileName of fileNames) {
+                    for (const fileName of fileNames) {
                         inputFiles.push(getHarnessCompilerInputUnit(fileName));
                     }
 
                     // Add files to compilation
-                    let isInInputList = (resolvedPath: string) => (inputFile: { unitName: string; content: string; }) => inputFile.unitName === resolvedPath;
-                    for (let fileRead of ioLog.filesRead) {
+                    const isInInputList = (resolvedPath: string) => (inputFile: { unitName: string; content: string; }) => inputFile.unitName === resolvedPath;
+                    for (const fileRead of ioLog.filesRead) {
                         // Check if the file is already added into the set of input files.
                         const resolvedPath = ts.normalizeSlashes(Harness.IO.resolvePath(fileRead.path));
-                        let inInputList = ts.forEach(inputFiles, isInInputList(resolvedPath));
+                        const inInputList = ts.forEach(inputFiles, isInInputList(resolvedPath));
 
                         if (isTsConfigFile(fileRead)) {
                             continue;
@@ -139,7 +139,7 @@ namespace RWC {
                 });
 
                 function getHarnessCompilerInputUnit(fileName: string) {
-                    let unitName = ts.normalizeSlashes(Harness.IO.resolvePath(fileName));
+                    const unitName = ts.normalizeSlashes(Harness.IO.resolvePath(fileName));
                     let content: string = null;
                     try {
                         content = Harness.IO.readFile(unitName);
@@ -201,7 +201,7 @@ namespace RWC {
             it("has the expected errors in generated declaration files", () => {
                 if (compilerOptions.declaration && !compilerResult.errors.length) {
                     Harness.Baseline.runBaseline("has the expected errors in generated declaration files", baseName + ".dts.errors.txt", () => {
-                        let declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult,
+                        const declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult,
                             /*settingscallback*/ undefined, compilerOptions, currentDirectory);
                         if (declFileCompilationResult.declResult.errors.length === 0) {
                             return null;
@@ -227,7 +227,7 @@ class RWCRunner extends RunnerBase {
      */
     public initializeTests(): void {
         // Read in and evaluate the test list
-        let testList = Harness.IO.listFiles(RWCRunner.sourcePath, /.+\.json$/);
+        const testList = Harness.IO.listFiles(RWCRunner.sourcePath, /.+\.json$/);
         for (let i = 0; i < testList.length; i++) {
             this.runTest(testList[i]);
         }
diff --git a/src/harness/sourceMapRecorder.ts b/src/harness/sourceMapRecorder.ts
index dcdc59a2a40..ce0a6a6528e 100644
--- a/src/harness/sourceMapRecorder.ts
+++ b/src/harness/sourceMapRecorder.ts
@@ -92,7 +92,7 @@ namespace Harness.SourceMapRecoder {
                     }
 
                     // 6 digit number
-                    let currentByte = base64FormatDecode();
+                    const currentByte = base64FormatDecode();
 
                     // If msb is set, we still have more bits to continue
                     moreDigits = (currentByte & 32) !== 0;
@@ -259,7 +259,7 @@ namespace Harness.SourceMapRecoder {
 
         export function recordSourceMapSpan(sourceMapSpan: ts.SourceMapSpan) {
             // verify the decoded span is same as the new span
-            let decodeResult = SourceMapDecoder.decodeNextEncodedSourceMapSpan();
+            const decodeResult = SourceMapDecoder.decodeNextEncodedSourceMapSpan();
             let decodedErrors: string[];
             if (decodeResult.error
                 || decodeResult.sourceMapSpan.emittedLine   !== sourceMapSpan.emittedLine
@@ -317,8 +317,8 @@ namespace Harness.SourceMapRecoder {
         }
 
         function getTextOfLine(line: number, lineMap: number[], code: string) {
-            let startPos = lineMap[line];
-            let endPos = lineMap[line + 1];
+            const startPos = lineMap[line];
+            const endPos = lineMap[line + 1];
             return code.substring(startPos, endPos);
         }
 
@@ -329,7 +329,7 @@ namespace Harness.SourceMapRecoder {
         }
 
         function writeRecordedSpans() {
-            let markerIds: string[] = [];
+            const markerIds: string[] = [];
 
             function getMarkerId(markerIndex: number) {
                 let markerId = "";
@@ -364,7 +364,7 @@ namespace Harness.SourceMapRecoder {
             }
 
             function writeSourceMapMarker(currentSpan: SourceMapSpanWithDecodeErrors, index: number, endColumn = currentSpan.sourceMapSpan.emittedColumn, endContinues?: boolean) {
-                let markerId = getMarkerId(index);
+                const markerId = getMarkerId(index);
                 markerIds.push(markerId);
 
                 writeSourceMapIndent(prevEmittedCol, markerId);
@@ -380,7 +380,7 @@ namespace Harness.SourceMapRecoder {
             }
 
             function writeSourceMapSourceText(currentSpan: SourceMapSpanWithDecodeErrors, index: number) {
-                let sourcePos = tsLineMap[currentSpan.sourceMapSpan.sourceLine - 1] + (currentSpan.sourceMapSpan.sourceColumn - 1);
+                const sourcePos = tsLineMap[currentSpan.sourceMapSpan.sourceLine - 1] + (currentSpan.sourceMapSpan.sourceColumn - 1);
                 let sourceText = "";
                 if (prevWrittenSourcePos < sourcePos) {
                     // Position that goes forward, get text
@@ -395,7 +395,7 @@ namespace Harness.SourceMapRecoder {
                     }
                 }
 
-                let tsCodeLineMap = ts.computeLineStarts(sourceText);
+                const tsCodeLineMap = ts.computeLineStarts(sourceText);
                 for (let i = 0; i < tsCodeLineMap.length; i++) {
                     writeSourceMapIndent(prevEmittedCol, i === 0 ? markerIds[index] : "  >");
                     sourceMapRecoder.Write(getTextOfLine(i, tsCodeLineMap, sourceText));
@@ -412,7 +412,7 @@ namespace Harness.SourceMapRecoder {
             }
 
             if (spansOnSingleLine.length) {
-                let currentJsLine = spansOnSingleLine[0].sourceMapSpan.emittedLine;
+                const currentJsLine = spansOnSingleLine[0].sourceMapSpan.emittedLine;
 
                 // Write js line
                 writeJsFileLines(currentJsLine);
@@ -420,7 +420,7 @@ namespace Harness.SourceMapRecoder {
                 // Emit markers
                 iterateSpans(writeSourceMapMarker);
 
-                let jsFileText = getTextOfLine(currentJsLine, jsLineMap, jsFile.code);
+                const jsFileText = getTextOfLine(currentJsLine, jsLineMap, jsFile.code);
                 if (prevEmittedCol < jsFileText.length) {
                     // There is remaining text on this line that will be part of next source span so write marker that continues
                     writeSourceMapMarker(undefined, spansOnSingleLine.length, /*endColumn*/ jsFileText.length, /*endContinues*/ true);
@@ -438,16 +438,16 @@ namespace Harness.SourceMapRecoder {
     }
 
     export function getSourceMapRecord(sourceMapDataList: ts.SourceMapData[], program: ts.Program, jsFiles: Compiler.GeneratedFile[]) {
-        let sourceMapRecoder = new Compiler.WriterAggregator();
+        const sourceMapRecoder = new Compiler.WriterAggregator();
 
         for (let i = 0; i < sourceMapDataList.length; i++) {
-            let sourceMapData = sourceMapDataList[i];
+            const sourceMapData = sourceMapDataList[i];
             let prevSourceFile: ts.SourceFile;
 
             SourceMapSpanWriter.intializeSourceMapSpanWriter(sourceMapRecoder, sourceMapData, jsFiles[i]);
             for (let j = 0; j < sourceMapData.sourceMapDecodedMappings.length; j++) {
-                let decodedSourceMapping = sourceMapData.sourceMapDecodedMappings[j];
-                let currentSourceFile = program.getSourceFile(sourceMapData.inputSourceFileNames[decodedSourceMapping.sourceIndex]);
+                const decodedSourceMapping = sourceMapData.sourceMapDecodedMappings[j];
+                const currentSourceFile = program.getSourceFile(sourceMapData.inputSourceFileNames[decodedSourceMapping.sourceIndex]);
                 if (currentSourceFile !== prevSourceFile) {
                     SourceMapSpanWriter.recordNewSourceFileSpan(decodedSourceMapping, currentSourceFile.text);
                     prevSourceFile = currentSourceFile;
diff --git a/src/harness/test262Runner.ts b/src/harness/test262Runner.ts
index 491c71a5839..f25e0c79b63 100644
--- a/src/harness/test262Runner.ts
+++ b/src/harness/test262Runner.ts
@@ -36,11 +36,11 @@ class Test262BaselineRunner extends RunnerBase {
             };
 
             before(() => {
-                let content = Harness.IO.readFile(filePath);
-                let testFilename = ts.removeFileExtension(filePath).replace(/\//g, "_") + ".test";
-                let testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, testFilename);
+                const content = Harness.IO.readFile(filePath);
+                const testFilename = ts.removeFileExtension(filePath).replace(/\//g, "_") + ".test";
+                const testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, testFilename);
 
-                let inputFiles = testCaseContent.testUnitData.map(unit => {
+                const inputFiles = testCaseContent.testUnitData.map(unit => {
                     return { unitName: Test262BaselineRunner.getTestFilePath(unit.name), content: unit.content };
                 });
 
@@ -64,14 +64,14 @@ class Test262BaselineRunner extends RunnerBase {
 
             it("has the expected emitted code", () => {
                 Harness.Baseline.runBaseline("has the expected emitted code", testState.filename + ".output.js", () => {
-                    let files = testState.compilerResult.files.filter(f => f.fileName !== Test262BaselineRunner.helpersFilePath);
+                    const files = testState.compilerResult.files.filter(f => f.fileName !== Test262BaselineRunner.helpersFilePath);
                     return Harness.Compiler.collateOutputs(files);
                 }, false, Test262BaselineRunner.baselineOptions);
             });
 
             it("has the expected errors", () => {
                 Harness.Baseline.runBaseline("has the expected errors", testState.filename + ".errors.txt", () => {
-                    let errors = testState.compilerResult.errors;
+                    const errors = testState.compilerResult.errors;
                     if (errors.length === 0) {
                         return null;
                     }
@@ -81,13 +81,13 @@ class Test262BaselineRunner extends RunnerBase {
             });
 
             it("satisfies inletiants", () => {
-                let sourceFile = testState.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
+                const sourceFile = testState.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
                 Utils.assertInvariants(sourceFile, /*parent:*/ undefined);
             });
 
             it("has the expected AST", () => {
                 Harness.Baseline.runBaseline("has the expected AST", testState.filename + ".AST.txt", () => {
-                    let sourceFile = testState.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
+                    const sourceFile = testState.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
                     return Utils.sourceFileToJSON(sourceFile);
                 }, false, Test262BaselineRunner.baselineOptions);
             });
@@ -97,7 +97,7 @@ class Test262BaselineRunner extends RunnerBase {
     public initializeTests() {
         // this will set up a series of describe/it blocks to run between the setup and cleanup phases
         if (this.tests.length === 0) {
-            let testFiles = this.enumerateFiles(Test262BaselineRunner.basePath, Test262BaselineRunner.testFileExtensionRegex, { recursive: true });
+            const testFiles = this.enumerateFiles(Test262BaselineRunner.basePath, Test262BaselineRunner.testFileExtensionRegex, { recursive: true });
             testFiles.forEach(fn => {
                 this.runTest(ts.normalizePath(fn));
             });
diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts
index 9db4fbcd41c..e332dab648e 100644
--- a/src/harness/typeWriter.ts
+++ b/src/harness/typeWriter.ts
@@ -21,7 +21,7 @@ class TypeWriterWalker {
     }
 
     public getTypeAndSymbols(fileName: string): TypeWriterResult[] {
-        let sourceFile = this.program.getSourceFile(fileName);
+        const sourceFile = this.program.getSourceFile(fileName);
         this.currentSourceFile = sourceFile;
         this.results = [];
         this.visitNode(sourceFile);
@@ -37,28 +37,28 @@ class TypeWriterWalker {
     }
 
     private logTypeAndSymbol(node: ts.Node): void {
-        let actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
-        let lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
-        let sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
+        const actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
+        const lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
+        const sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
 
         // Workaround to ensure we output 'C' instead of 'typeof C' for base class expressions
         // let type = this.checker.getTypeAtLocation(node);
-        let type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node);
+        const type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node);
 
         ts.Debug.assert(type !== undefined, "type doesn't exist");
-        let symbol = this.checker.getSymbolAtLocation(node);
+        const symbol = this.checker.getSymbolAtLocation(node);
 
-        let typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
+        const typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
         let symbolString: string;
         if (symbol) {
             symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
             if (symbol.declarations) {
-                for (let declaration of symbol.declarations) {
+                for (const declaration of symbol.declarations) {
                     symbolString += ", ";
-                    let declSourceFile = declaration.getSourceFile();
-                    let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
-                    let fileName = ts.getBaseFileName(declSourceFile.fileName);
-                    let isLibFile = /lib(.*)\.d\.ts/i.test(fileName);
+                    const declSourceFile = declaration.getSourceFile();
+                    const declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
+                    const fileName = ts.getBaseFileName(declSourceFile.fileName);
+                    const isLibFile = /lib(.*)\.d\.ts/i.test(fileName);
                     symbolString += `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`;
                 }
             }
diff --git a/src/lib/README.md b/src/lib/README.md
new file mode 100644
index 00000000000..cbf80e4d0da
--- /dev/null
+++ b/src/lib/README.md
@@ -0,0 +1,8 @@
+# Read this!
+
+The files within this directory are used to generate `lib.d.ts` and `lib.es6.d.ts`.
+
+## Generated files
+
+Any files ending in `.generated.d.ts` aren't mean to be edited by hand.
+If you need to make changes to such files, make a change to the input files for our [library generator](https://github.com/Microsoft/TSJS-lib-generator).
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 7eee32b4c0f..8d5ecb1b237 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -105,19 +105,19 @@ namespace ts.server {
         }
 
         resolveModuleNames(moduleNames: string[], containingFile: string): ResolvedModule[] {
-            let path = toPath(containingFile, this.host.getCurrentDirectory(), this.getCanonicalFileName);
-            let currentResolutionsInFile = this.resolvedModuleNames.get(path);
+            const path = toPath(containingFile, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+            const currentResolutionsInFile = this.resolvedModuleNames.get(path);
 
-            let newResolutions: Map<TimestampedResolvedModule> = {};
-            let resolvedModules: ResolvedModule[] = [];
+            const newResolutions: Map<TimestampedResolvedModule> = {};
+            const resolvedModules: ResolvedModule[] = [];
 
-            let compilerOptions = this.getCompilationSettings();
+            const compilerOptions = this.getCompilationSettings();
 
-            for (let moduleName of moduleNames) {
+            for (const moduleName of moduleNames) {
                 // check if this is a duplicate entry in the list
                 let resolution = lookUp(newResolutions, moduleName);
                 if (!resolution) {
-                    let existingResolution = currentResolutionsInFile && ts.lookUp(currentResolutionsInFile, moduleName);
+                    const existingResolution = currentResolutionsInFile && ts.lookUp(currentResolutionsInFile, moduleName);
                     if (moduleResolutionIsValid(existingResolution)) {
                         // ok, it is safe to use existing module resolution results  
                         resolution = existingResolution;
@@ -211,7 +211,7 @@ namespace ts.server {
         }
 
         getScriptInfo(filename: string): ScriptInfo {
-            let path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+            const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
             let scriptInfo = this.filenameToScript.get(path);
             if (!scriptInfo) {
                 scriptInfo = this.project.openReferencedFile(filename);
@@ -282,7 +282,7 @@ namespace ts.server {
          *  @param line 1 based index
          */
         lineToTextSpan(filename: string, line: number): ts.TextSpan {
-            let path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+            const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
             const script: ScriptInfo = this.filenameToScript.get(path);
             const index = script.snap().index;
 
@@ -303,7 +303,7 @@ namespace ts.server {
          * @param offset 1 based index
          */
         lineOffsetToPosition(filename: string, line: number, offset: number): number {
-            let path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+            const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
             const script: ScriptInfo = this.filenameToScript.get(path);
             const index = script.snap().index;
 
@@ -317,7 +317,7 @@ namespace ts.server {
          * @param offset 1-based index
          */
         positionToLineOffset(filename: string, position: number): ILineInfo {
-            let path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
+            const path = toPath(filename, this.host.getCurrentDirectory(), this.getCanonicalFileName);
             const script: ScriptInfo = this.filenameToScript.get(path);
             const index = script.snap().index;
             const lineOffset = index.charOffsetToLineNumberAndPos(position);
@@ -578,9 +578,9 @@ namespace ts.server {
         }
 
         handleProjectFilelistChanges(project: Project) {
-            let { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
-            let newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));
-            let currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));
+            const { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
+            const newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));
+            const currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));
 
             // We check if the project file list has changed. If so, we update the project.
             if (!arrayIsEqualTo(currentRootFiles && currentRootFiles.sort(), newRootFiles && newRootFiles.sort())) {
@@ -606,13 +606,13 @@ namespace ts.server {
 
             this.log("Detected newly added tsconfig file: " + fileName);
 
-            let { succeeded, projectOptions, error } = this.configFileToProjectOptions(fileName);
-            let rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));
-            let openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));
+            const { succeeded, projectOptions, error } = this.configFileToProjectOptions(fileName);
+            const rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));
+            const openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));
 
             // We should only care about the new tsconfig file if it contains any
             // opened root files of existing inferred projects
-            for (let openFileRoot of openFileRoots) {
+            for (const openFileRoot of openFileRoots) {
                 if (rootFilesInTsconfig.indexOf(openFileRoot) >= 0) {
                     this.reloadProjects();
                     return;
@@ -621,7 +621,7 @@ namespace ts.server {
         }
 
         getCanonicalFileName(fileName: string) {
-            let name = this.host.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+            const name = this.host.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
             return ts.normalizePath(name);
         }
 
@@ -737,7 +737,7 @@ namespace ts.server {
                 this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);
             }
             else {
-                for (let directory of project.directoriesWatchedForTsconfig) {
+                for (const directory of project.directoriesWatchedForTsconfig) {
                     // if the ref count for this directory watcher drops to 0, it's time to close it
                     if (!(--project.projectService.directoryWatchersRefCount[directory])) {
                         this.log("Close directory watcher for: " + directory);
@@ -748,9 +748,9 @@ namespace ts.server {
                 this.inferredProjects = copyListRemovingItem(project, this.inferredProjects);
             }
 
-            let fileNames = project.getFileNames();
-            for (let fileName of fileNames) {
-                let info = this.getScriptInfo(fileName);
+            const fileNames = project.getFileNames();
+            for (const fileName of fileNames) {
+                const info = this.getScriptInfo(fileName);
                 if (info.defaultProject == project) {
                     info.defaultProject = undefined;
                 }
@@ -759,7 +759,7 @@ namespace ts.server {
 
         setConfiguredProjectRoot(info: ScriptInfo) {
             for (let i = 0, len = this.configuredProjects.length; i < len; i++) {
-                let configuredProject = this.configuredProjects[i];
+                const configuredProject = this.configuredProjects[i];
                 if (configuredProject.isRoot(info)) {
                     info.defaultProject = configuredProject;
                     configuredProject.addOpenRef();
@@ -903,7 +903,7 @@ namespace ts.server {
         reloadProjects() {
             this.log("reload projects.");
             // First check if there is new tsconfig file added for inferred project roots
-            for (let info of this.openFileRoots) {
+            for (const info of this.openFileRoots) {
                 this.openOrUpdateConfiguredProjectForFile(info.fileName);
             }
             this.updateProjectStructure();
@@ -918,10 +918,10 @@ namespace ts.server {
             this.log("updating project structure from ...", "Info");
             this.printProjects();
 
-            let unattachedOpenFiles: ScriptInfo[] = [];
-            let openFileRootsConfigured: ScriptInfo[] = [];
-            for (let info of this.openFileRootsConfigured) {
-                let project = info.defaultProject;
+            const unattachedOpenFiles: ScriptInfo[] = [];
+            const openFileRootsConfigured: ScriptInfo[] = [];
+            for (const info of this.openFileRootsConfigured) {
+                const project = info.defaultProject;
                 if (!project || !(project.getSourceFile(info))) {
                     info.defaultProject = undefined;
                     unattachedOpenFiles.push(info);
@@ -1016,7 +1016,6 @@ namespace ts.server {
                     }
                 }
                 if (content !== undefined) {
-                    let indentSize: number;
                     info = new ScriptInfo(this.host, fileName, content, openedByClient);
                     info.setFormatOptions(this.getFormatCodeOptions());
                     this.filenameToScriptInfo[fileName] = info;
@@ -1071,12 +1070,12 @@ namespace ts.server {
          * the tsconfig file content and update the project; otherwise we create a new one. 
          */
         openOrUpdateConfiguredProjectForFile(fileName: string) {
-            let searchPath = ts.normalizePath(getDirectoryPath(fileName));
+            const searchPath = ts.normalizePath(getDirectoryPath(fileName));
             this.log("Search path: " + searchPath, "Info");
-            let configFileName = this.findConfigFile(searchPath);
+            const configFileName = this.findConfigFile(searchPath);
             if (configFileName) {
                 this.log("Config file name: " + configFileName, "Info");
-                let project = this.findConfiguredProjectByConfigFile(configFileName);
+                const project = this.findConfiguredProjectByConfigFile(configFileName);
                 if (!project) {
                     const configResult = this.openConfigFile(configFileName, fileName);
                     if (!configResult.success) {
@@ -1215,15 +1214,15 @@ namespace ts.server {
         }
 
         openConfigFile(configFilename: string, clientFileName?: string): ProjectOpenResult {
-            let { succeeded, projectOptions, error } = this.configFileToProjectOptions(configFilename);
+            const { succeeded, projectOptions, error } = this.configFileToProjectOptions(configFilename);
             if (!succeeded) {
                 return error;
             }
             else {
-                let project = this.createProject(configFilename, projectOptions);
-                for (let rootFilename of projectOptions.files) {
+                const project = this.createProject(configFilename, projectOptions);
+                for (const rootFilename of projectOptions.files) {
                     if (this.host.fileExists(rootFilename)) {
-                        let info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
+                        const info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
                         project.addRoot(info);
                     }
                     else {
@@ -1248,24 +1247,24 @@ namespace ts.server {
                 this.removeProject(project);
             }
             else {
-                let { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
+                const { succeeded, projectOptions, error } = this.configFileToProjectOptions(project.projectFilename);
                 if (!succeeded) {
                     return error;
                 }
                 else {
-                    let oldFileNames = project.compilerService.host.roots.map(info => info.fileName);
-                    let newFileNames = projectOptions.files;
-                    let fileNamesToRemove = oldFileNames.filter(f => newFileNames.indexOf(f) < 0);
-                    let fileNamesToAdd = newFileNames.filter(f => oldFileNames.indexOf(f) < 0);
+                    const oldFileNames = project.compilerService.host.roots.map(info => info.fileName);
+                    const newFileNames = projectOptions.files;
+                    const fileNamesToRemove = oldFileNames.filter(f => newFileNames.indexOf(f) < 0);
+                    const fileNamesToAdd = newFileNames.filter(f => oldFileNames.indexOf(f) < 0);
 
-                    for (let fileName of fileNamesToRemove) {
-                        let info = this.getScriptInfo(fileName);
+                    for (const fileName of fileNamesToRemove) {
+                        const info = this.getScriptInfo(fileName);
                         if (info) {
                             project.removeRoot(info);
                         }
                     }
 
-                    for (let fileName of fileNamesToAdd) {
+                    for (const fileName of fileNamesToAdd) {
                         let info = this.getScriptInfo(fileName);
                         if (!info) {
                             info = this.openFile(fileName, false);
diff --git a/src/server/server.ts b/src/server/server.ts
index 842dfef28c0..e29e79ac6ed 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -157,7 +157,7 @@ namespace ts.server {
 
     const logger = createLoggerFromEnv();
 
-    let pending: string[] = [];
+    const pending: string[] = [];
     let canWrite = true;
     function writeMessage(s: string) {
         if (!canWrite) {
diff --git a/src/server/session.ts b/src/server/session.ts
index 694fcebf630..770256cc9f7 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -338,25 +338,25 @@ namespace ts.server {
 
         private getOccurrences(line: number, offset: number, fileName: string): protocol.OccurrencesResponseItem[] {
             fileName = ts.normalizePath(fileName);
-            let project = this.projectService.getProjectForFile(fileName);
+            const project = this.projectService.getProjectForFile(fileName);
 
             if (!project) {
                 throw Errors.NoProject;
             }
 
-            let { compilerService } = project;
-            let position = compilerService.host.lineOffsetToPosition(fileName, line, offset);
+            const { compilerService } = project;
+            const position = compilerService.host.lineOffsetToPosition(fileName, line, offset);
 
-            let occurrences = compilerService.languageService.getOccurrencesAtPosition(fileName, position);
+            const occurrences = compilerService.languageService.getOccurrencesAtPosition(fileName, position);
 
             if (!occurrences) {
                 return undefined;
             }
 
             return occurrences.map(occurrence => {
-                let { fileName, isWriteAccess, textSpan } = occurrence;
-                let start = compilerService.host.positionToLineOffset(fileName, textSpan.start);
-                let end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));
+                const { fileName, isWriteAccess, textSpan } = occurrence;
+                const start = compilerService.host.positionToLineOffset(fileName, textSpan.start);
+                const end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));
                 return {
                     start,
                     end,
@@ -368,16 +368,16 @@ namespace ts.server {
 
         private getDocumentHighlights(line: number, offset: number, fileName: string, filesToSearch: string[]): protocol.DocumentHighlightsItem[] {
             fileName = ts.normalizePath(fileName);
-            let project = this.projectService.getProjectForFile(fileName);
+            const project = this.projectService.getProjectForFile(fileName);
 
             if (!project) {
                 throw Errors.NoProject;
             }
 
-            let { compilerService } = project;
-            let position = compilerService.host.lineOffsetToPosition(fileName, line, offset);
+            const { compilerService } = project;
+            const position = compilerService.host.lineOffsetToPosition(fileName, line, offset);
 
-            let documentHighlights = compilerService.languageService.getDocumentHighlights(fileName, position, filesToSearch);
+            const documentHighlights = compilerService.languageService.getDocumentHighlights(fileName, position, filesToSearch);
 
             if (!documentHighlights) {
                 return undefined;
@@ -386,7 +386,7 @@ namespace ts.server {
             return documentHighlights.map(convertToDocumentHighlightsItem);
 
             function convertToDocumentHighlightsItem(documentHighlights: ts.DocumentHighlights): ts.server.protocol.DocumentHighlightsItem {
-                let { fileName, highlightSpans } = documentHighlights;
+                const { fileName, highlightSpans } = documentHighlights;
 
                 return {
                     file: fileName,
@@ -394,9 +394,9 @@ namespace ts.server {
                 };
 
                 function convertHighlightSpan(highlightSpan: ts.HighlightSpan): ts.server.protocol.HighlightSpan {
-                    let { textSpan, kind } = highlightSpan;
-                    let start = compilerService.host.positionToLineOffset(fileName, textSpan.start);
-                    let end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));
+                    const { textSpan, kind } = highlightSpan;
+                    const start = compilerService.host.positionToLineOffset(fileName, textSpan.start);
+                    const end = compilerService.host.positionToLineOffset(fileName, ts.textSpanEnd(textSpan));
                     return { start, end, kind };
                 }
             }
@@ -404,9 +404,9 @@ namespace ts.server {
 
         private getProjectInfo(fileName: string, needFileNameList: boolean): protocol.ProjectInfo {
             fileName = ts.normalizePath(fileName);
-            let project = this.projectService.getProjectForFile(fileName);
+            const project = this.projectService.getProjectForFile(fileName);
 
-            let projectInfo: protocol.ProjectInfo = {
+            const projectInfo: protocol.ProjectInfo = {
                 configFileName: project.projectFilename
             };
 
@@ -640,7 +640,7 @@ namespace ts.server {
                             }
                             // i points to the first non whitespace character
                             if (preferredIndent !== hasIndent) {
-                                let firstNoWhiteSpacePosition = lineInfo.offset + i;
+                                const firstNoWhiteSpacePosition = lineInfo.offset + i;
                                 edits.push({
                                     span: ts.createTextSpanFromBounds(lineInfo.offset, firstNoWhiteSpacePosition),
                                     newText: generateIndentString(preferredIndent, editorOptions)
@@ -897,22 +897,22 @@ namespace ts.server {
         }
 
         getDiagnosticsForProject(delay: number, fileName: string) {
-            let { configFileName, fileNames: fileNamesInProject } = this.getProjectInfo(fileName, true);
+            const { configFileName, fileNames } = this.getProjectInfo(fileName, true);
             // No need to analyze lib.d.ts
-            fileNamesInProject = fileNamesInProject.filter((value, index, array) => value.indexOf("lib.d.ts") < 0);
+            let fileNamesInProject = fileNames.filter((value, index, array) => value.indexOf("lib.d.ts") < 0);
 
             // Sort the file name list to make the recently touched files come first
-            let highPriorityFiles: string[] = [];
-            let mediumPriorityFiles: string[] = [];
-            let lowPriorityFiles: string[] = [];
-            let veryLowPriorityFiles: string[] = [];
-            let normalizedFileName = ts.normalizePath(fileName);
-            let project = this.projectService.getProjectForFile(normalizedFileName);
-            for (let fileNameInProject of fileNamesInProject) {
+            const highPriorityFiles: string[] = [];
+            const mediumPriorityFiles: string[] = [];
+            const lowPriorityFiles: string[] = [];
+            const veryLowPriorityFiles: string[] = [];
+            const normalizedFileName = ts.normalizePath(fileName);
+            const project = this.projectService.getProjectForFile(normalizedFileName);
+            for (const fileNameInProject of fileNamesInProject) {
                 if (this.getCanonicalFileName(fileNameInProject) == this.getCanonicalFileName(fileName))
                     highPriorityFiles.push(fileNameInProject);
                 else {
-                    let info = this.projectService.getScriptInfo(fileNameInProject);
+                    const info = this.projectService.getScriptInfo(fileNameInProject);
                     if (!info.isOpen) {
                         if (fileNameInProject.indexOf(".d.ts") > 0)
                             veryLowPriorityFiles.push(fileNameInProject);
@@ -927,8 +927,8 @@ namespace ts.server {
             fileNamesInProject = highPriorityFiles.concat(mediumPriorityFiles).concat(lowPriorityFiles).concat(veryLowPriorityFiles);
 
             if (fileNamesInProject.length > 0) {
-                let checkList = fileNamesInProject.map<PendingErrorCheck>((fileName: string) => {
-                    let normalizedFileName = ts.normalizePath(fileName);
+                const checkList = fileNamesInProject.map<PendingErrorCheck>((fileName: string) => {
+                    const normalizedFileName = ts.normalizePath(fileName);
                     return { fileName: normalizedFileName, project };
                 });
                 // Project level error analysis runs on background files too, therefore
@@ -938,7 +938,7 @@ namespace ts.server {
         }
 
         getCanonicalFileName(fileName: string) {
-            let name = this.host.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+            const name = this.host.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
             return ts.normalizePath(name);
         }
 
@@ -1001,7 +1001,7 @@ namespace ts.server {
                 return {response: this.getDiagnostics(geterrArgs.delay, geterrArgs.files), responseRequired: false};
             },
             [CommandNames.GeterrForProject]: (request: protocol.Request) => {
-                let { file, delay } = <protocol.GeterrForProjectRequestArgs>request.arguments;
+                const { file, delay } = <protocol.GeterrForProjectRequestArgs>request.arguments;
                 return {response: this.getDiagnosticsForProject(delay, file), responseRequired: false};
             },
             [CommandNames.Change]: (request: protocol.Request) => {
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
index 227ba6a7970..e307b21979e 100644
--- a/src/services/breakpoints.ts
+++ b/src/services/breakpoints.ts
@@ -446,7 +446,7 @@ namespace ts.BreakpointResolver {
                         // fall through.
 
                     case SyntaxKind.CatchClause:
-                        return spanInNode(lastOrUndefined((<Block>node.parent).statements));;
+                        return spanInNode(lastOrUndefined((<Block>node.parent).statements));
 
                     case SyntaxKind.CaseBlock:
                         // breakpoint in last statement of the last clause
@@ -493,9 +493,6 @@ namespace ts.BreakpointResolver {
                     default:
                         return spanInNode(node.parent);
                 }
-
-                // Default to parent node
-                return spanInNode(node.parent);
             }
 
             function spanInColonToken(node: Node): TextSpan {
diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts
index 3b68cd0ebb2..de1d1b19cf2 100644
--- a/src/services/formatting/smartIndenter.ts
+++ b/src/services/formatting/smartIndenter.ts
@@ -360,7 +360,6 @@ namespace ts.formatting {
                             return node;
                     }
                 }
-                return node;
             }
         }
 
diff --git a/src/services/navigateTo.ts b/src/services/navigateTo.ts
index bc506bc22f9..2a0abba8695 100644
--- a/src/services/navigateTo.ts
+++ b/src/services/navigateTo.ts
@@ -6,6 +6,9 @@ namespace ts.NavigateTo {
         let patternMatcher = createPatternMatcher(searchValue);
         let rawItems: RawNavigateToItem[] = [];
 
+        // This means "compare in a case insensitive manner."
+        let baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" };
+
         // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] 
         forEach(program.getSourceFiles(), sourceFile => {
             cancellationToken.throwIfCancellationRequested();
@@ -162,8 +165,6 @@ namespace ts.NavigateTo {
             return bestMatchKind;
         }
 
-        // This means "compare in a case insensitive manner."
-        let baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" };
         function compareNavigateToItems(i1: RawNavigateToItem, i2: RawNavigateToItem) {
             // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
             // Right now we just sort by kind first, and then by name of the item.
diff --git a/src/services/services.ts b/src/services/services.ts
index fe3e1dd40e8..25cb6a8b3ce 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -4774,7 +4774,7 @@ namespace ts {
                         else if (!isFunctionLike(node)) {
                             forEachChild(node, aggregate);
                         }
-                    };
+                    }
                 }
 
                 /**
@@ -4821,7 +4821,7 @@ namespace ts {
                         else if (!isFunctionLike(node)) {
                             forEachChild(node, aggregate);
                         }
-                    };
+                    }
                 }
 
                 function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
@@ -6130,8 +6130,6 @@ namespace ts {
             }
 
             return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
-
-            Debug.fail("Unknown declaration type");
         }
 
         function isTypeReference(node: Node): boolean {
diff --git a/src/services/shims.ts b/src/services/shims.ts
index e919625395d..8482cb50975 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -323,7 +323,6 @@ namespace ts {
             // TODO: should this be '==='?
             if (settingsJson == null || settingsJson == "") {
                 throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
-                return null;
             }
             return <CompilerOptions>JSON.parse(settingsJson);
         }
diff --git a/tests/baselines/reference/ES3For-ofTypeCheck4.js b/tests/baselines/reference/ES3For-ofTypeCheck4.js
index 7386a1967eb..a628a81c517 100644
--- a/tests/baselines/reference/ES3For-ofTypeCheck4.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES3For-ofTypeCheck6.js b/tests/baselines/reference/ES3For-ofTypeCheck6.js
index ddc11808b18..8b4a917eb85 100644
--- a/tests/baselines/reference/ES3For-ofTypeCheck6.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-of24.js b/tests/baselines/reference/ES5For-of24.js
index cdc0876692f..ce4376ad648 100644
--- a/tests/baselines/reference/ES5For-of24.js
+++ b/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;
 }
diff --git a/tests/baselines/reference/ES5For-of25.js b/tests/baselines/reference/ES5For-of25.js
index 756c14fbe81..440c0b55efb 100644
--- a/tests/baselines/reference/ES5For-of25.js
+++ b/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;
 }
diff --git a/tests/baselines/reference/ES5For-of25.js.map b/tests/baselines/reference/ES5For-of25.js.map
index cc31767128b..1c4d8c2101f 100644
--- a/tests/baselines/reference/ES5For-of25.js.map
+++ b/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"}
\ No newline at end of file
+{"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"}
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-of25.sourcemap.txt b/tests/baselines/reference/ES5For-of25.sourcemap.txt
index 623627fde20..453eef4ee46 100644
--- a/tests/baselines/reference/ES5For-of25.sourcemap.txt
+++ b/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 >^^^^
diff --git a/tests/baselines/reference/ES5For-of30.js b/tests/baselines/reference/ES5For-of30.js
index 2a1dc5a3399..fead25e7cf0 100644
--- a/tests/baselines/reference/ES5For-of30.js
+++ b/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;
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck11.js b/tests/baselines/reference/ES5For-ofTypeCheck11.js
index c0e46a45452..ce439427755 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck11.js
+++ 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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck3.js b/tests/baselines/reference/ES5For-ofTypeCheck3.js
index 76d8237997b..61a60727cba 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck3.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck4.js b/tests/baselines/reference/ES5For-ofTypeCheck4.js
index 630bc869c58..6240b6a799a 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck4.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck5.js b/tests/baselines/reference/ES5For-ofTypeCheck5.js
index 2e6b47f779d..0d285d67d8b 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck5.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck6.js b/tests/baselines/reference/ES5For-ofTypeCheck6.js
index 9249020b9d4..c99fd415b23 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck6.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck7.js b/tests/baselines/reference/ES5For-ofTypeCheck7.js
index d5b74a24728..1bd360e5132 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck7.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck8.js b/tests/baselines/reference/ES5For-ofTypeCheck8.js
index d73aea1cb7b..ae4a823a18c 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck8.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck9.js b/tests/baselines/reference/ES5For-ofTypeCheck9.js
index 6c7465d10ec..3e18c2da31f 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck9.js
+++ b/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];
 }
diff --git a/tests/baselines/reference/ES5for-of32.js b/tests/baselines/reference/ES5for-of32.js
new file mode 100644
index 00000000000..7af7cc3874a
--- /dev/null
+++ b/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;
+}
diff --git a/tests/baselines/reference/ES5for-of32.symbols b/tests/baselines/reference/ES5for-of32.symbols
new file mode 100644
index 00000000000..5672ad01109
--- /dev/null
+++ b/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))
+}
diff --git a/tests/baselines/reference/ES5for-of32.types b/tests/baselines/reference/ES5for-of32.types
new file mode 100644
index 00000000000..6fe5ba2008b
--- /dev/null
+++ b/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
+}
diff --git a/tests/baselines/reference/ParameterList5.errors.txt b/tests/baselines/reference/ParameterList5.errors.txt
index 02b86633b95..618ce740915 100644
--- a/tests/baselines/reference/ParameterList5.errors.txt
+++ b/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.
                                 ~
diff --git a/tests/baselines/reference/YieldExpression17_es6.errors.txt b/tests/baselines/reference/YieldExpression17_es6.errors.txt
index bc262212526..f987517371f 100644
--- a/tests/baselines/reference/YieldExpression17_es6.errors.txt
+++ b/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.
\ No newline at end of file
diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES5.js b/tests/baselines/reference/argumentsObjectIterator01_ES5.js
index bc51d6f5582..8378528dbf4 100644
--- a/tests/baselines/reference/argumentsObjectIterator01_ES5.js
+++ b/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;
diff --git a/tests/baselines/reference/assignmentLHSIsValue.errors.txt b/tests/baselines/reference/assignmentLHSIsValue.errors.txt
index cf747b44b3e..bf253df5e70 100644
--- a/tests/baselines/reference/assignmentLHSIsValue.errors.txt
+++ b/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.
     
diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt
index 2476eaec6e3..08e59e69b9f 100644
--- a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt
+++ b/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;
               ~~~~~
diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt
index 978492f0744..43df8e21659 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt
+++ b/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.
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncGetter_es6.errors.txt b/tests/baselines/reference/asyncGetter_es6.errors.txt
index 5f5a9f6b1d7..f6deea16d06 100644
--- a/tests/baselines/reference/asyncGetter_es6.errors.txt
+++ b/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.
       }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.js b/tests/baselines/reference/bestCommonTypeReturnStatement.js
index f4ab98ed1c6..6d6f73bc0cf 100644
--- a/tests/baselines/reference/bestCommonTypeReturnStatement.js
+++ b/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>;
 }
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols
index 43e04ef037d..14e770ae255 100644
--- a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols
+++ b/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))
 
diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.types b/tests/baselines/reference/bestCommonTypeReturnStatement.types
index 28974f064a5..31f72ab93b4 100644
--- a/tests/baselines/reference/bestCommonTypeReturnStatement.types
+++ b/tests/baselines/reference/bestCommonTypeReturnStatement.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/bestCommonTypeReturnStatement.ts ===
+
 interface IPromise<T> {
 >IPromise : IPromise<T>
 >T : T
diff --git a/tests/baselines/reference/breakTarget3.js b/tests/baselines/reference/breakTarget3.js
index 0fa6cd2d298..b36eeb3902b 100644
--- a/tests/baselines/reference/breakTarget3.js
+++ b/tests/baselines/reference/breakTarget3.js
@@ -1,4 +1,5 @@
 //// [breakTarget3.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/breakTarget3.symbols b/tests/baselines/reference/breakTarget3.symbols
index 580706bbd4a..a0b17435504 100644
--- a/tests/baselines/reference/breakTarget3.symbols
+++ b/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;
diff --git a/tests/baselines/reference/breakTarget3.types b/tests/baselines/reference/breakTarget3.types
index 785bf00ef6e..e4b5f8a1c61 100644
--- a/tests/baselines/reference/breakTarget3.types
+++ b/tests/baselines/reference/breakTarget3.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/breakTarget3.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/breakTarget4.js b/tests/baselines/reference/breakTarget4.js
index 4586301d71b..0c91e44ecbd 100644
--- a/tests/baselines/reference/breakTarget4.js
+++ b/tests/baselines/reference/breakTarget4.js
@@ -1,4 +1,5 @@
 //// [breakTarget4.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/breakTarget4.symbols b/tests/baselines/reference/breakTarget4.symbols
index aba35ddcfdf..d4edcb17e1a 100644
--- a/tests/baselines/reference/breakTarget4.symbols
+++ b/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;
diff --git a/tests/baselines/reference/breakTarget4.types b/tests/baselines/reference/breakTarget4.types
index eb4c14f6386..8b6ccf600ad 100644
--- a/tests/baselines/reference/breakTarget4.types
+++ b/tests/baselines/reference/breakTarget4.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/breakTarget4.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/breakTarget5.errors.txt b/tests/baselines/reference/breakTarget5.errors.txt
index a54a415b990..d92f29d67ee 100644
--- a/tests/baselines/reference/breakTarget5.errors.txt
+++ b/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() {
diff --git a/tests/baselines/reference/breakTarget5.js b/tests/baselines/reference/breakTarget5.js
index 197e4e147bd..9f6b063a8c4 100644
--- a/tests/baselines/reference/breakTarget5.js
+++ b/tests/baselines/reference/breakTarget5.js
@@ -1,4 +1,5 @@
 //// [breakTarget5.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js
index 0e78aac2b1b..73270c240cb 100644
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js
+++ b/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
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
index 1c5a6786ab7..faba4e427ec 100644
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols
+++ b/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))
 
diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types
index 760451eb9c1..689ac62c35b 100644
--- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types
+++ b/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
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.js b/tests/baselines/reference/capturedLetConstInLoop9.js
index ecdf54d6fd1..93aef628f8a 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9.js
+++ b/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];
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.symbols b/tests/baselines/reference/capturedLetConstInLoop9.symbols
index 5ccc1c399f3..37d1764b41b 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9.symbols
+++ b/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, --, --))
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.types b/tests/baselines/reference/capturedLetConstInLoop9.types
index 5a19361b02e..7f793ab6601 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9.types
+++ b/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
         }
 
         
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
index 4605cada8a3..0c9d8ea6a68 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
+++ b/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);
     }
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
index d1d124b85f7..d71a20afe47 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
+++ b/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, --, --))
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
index e5afe21a29f..dfbfa387ed4 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
+++ b/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
         }
 
         
diff --git a/tests/baselines/reference/cf.errors.txt b/tests/baselines/reference/cf.errors.txt
new file mode 100644
index 00000000000..75b285c37c6
--- /dev/null
+++ b/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;
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/cf.symbols b/tests/baselines/reference/cf.symbols
deleted file mode 100644
index 9c2d73f5134..00000000000
--- a/tests/baselines/reference/cf.symbols
+++ /dev/null
@@ -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;
-    }
-}
-
diff --git a/tests/baselines/reference/cf.types b/tests/baselines/reference/cf.types
deleted file mode 100644
index 397e3469ece..00000000000
--- a/tests/baselines/reference/cf.types
+++ /dev/null
@@ -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;
-    }
-}
-
diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.js b/tests/baselines/reference/commentEmitAtEndOfFile1.js
index 1be031fa84a..cada7754002 100644
--- a/tests/baselines/reference/commentEmitAtEndOfFile1.js
+++ b/tests/baselines/reference/commentEmitAtEndOfFile1.js
@@ -1,4 +1,5 @@
 //// [commentEmitAtEndOfFile1.ts]
+
 // test
 var f = ''
 // test #2
diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols
index 1fc0ad09553..cb06d088307 100644
--- a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols
+++ b/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
diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.types b/tests/baselines/reference/commentEmitAtEndOfFile1.types
index d88d7ffa5fc..f96a1069a06 100644
--- a/tests/baselines/reference/commentEmitAtEndOfFile1.types
+++ b/tests/baselines/reference/commentEmitAtEndOfFile1.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/commentEmitAtEndOfFile1.ts ===
+
 // test
 var f = ''
 >f : string
diff --git a/tests/baselines/reference/commentsAtEndOfFile1.js b/tests/baselines/reference/commentsAtEndOfFile1.js
index 2d4dae39e6b..d93dded59b0 100644
--- a/tests/baselines/reference/commentsAtEndOfFile1.js
+++ b/tests/baselines/reference/commentsAtEndOfFile1.js
@@ -1,4 +1,5 @@
 //// [commentsAtEndOfFile1.ts]
+
 Input:
 ;
 //Testing two
diff --git a/tests/baselines/reference/commentsAtEndOfFile1.symbols b/tests/baselines/reference/commentsAtEndOfFile1.symbols
index c09a435f1a7..d35b4f251f6 100644
--- a/tests/baselines/reference/commentsAtEndOfFile1.symbols
+++ b/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.
diff --git a/tests/baselines/reference/commentsAtEndOfFile1.types b/tests/baselines/reference/commentsAtEndOfFile1.types
index 6bac6757061..71eb367738b 100644
--- a/tests/baselines/reference/commentsAtEndOfFile1.types
+++ b/tests/baselines/reference/commentsAtEndOfFile1.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/commentsAtEndOfFile1.ts ===
+
 Input:
 >Input : any
 
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
index 7b26fc4bf9e..392e1781dd5 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt
+++ b/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;
     
diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.js b/tests/baselines/reference/compoundAssignmentLHSIsValue.js
index 833c1e1ea7c..bf66183b70a 100644
--- a/tests/baselines/reference/compoundAssignmentLHSIsValue.js
+++ b/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;
 
diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
index bee6f75ff5c..23720468bb7 100644
--- a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt
+++ b/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.
     
diff --git a/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt
index 2fbf68b4437..e704126c055 100644
--- a/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt
+++ b/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) { }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt
index 3f18a8764b4..6b294981638 100644
--- a/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt
+++ b/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) { }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt
index a31965dc69e..fd6f8e8bdc1 100644
--- a/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt
+++ b/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) { }
diff --git a/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt
index b9009112347..4299437777d 100644
--- a/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt
+++ b/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) { }
diff --git a/tests/baselines/reference/conditionalExpressions2.js b/tests/baselines/reference/conditionalExpressions2.js
index 6749a2c0ac0..8ac7df12cfa 100644
--- a/tests/baselines/reference/conditionalExpressions2.js
+++ b/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;
diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols
index 63c8b417477..e6edd635b40 100644
--- a/tests/baselines/reference/conditionalExpressions2.symbols
+++ b/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))
 
diff --git a/tests/baselines/reference/conditionalExpressions2.types b/tests/baselines/reference/conditionalExpressions2.types
index 5f49410b1e4..77714e664fb 100644
--- a/tests/baselines/reference/conditionalExpressions2.types
+++ b/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
diff --git a/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt b/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt
index 0b667108b5f..afae9d40431 100644
--- a/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt
+++ b/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.
\ No newline at end of file
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
\ No newline at end of file
diff --git a/tests/baselines/reference/constDeclarations-scopes.errors.txt b/tests/baselines/reference/constDeclarations-scopes.errors.txt
index 138acd9b16d..4c9f7ce5163 100644
--- a/tests/baselines/reference/constDeclarations-scopes.errors.txt
+++ b/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);
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
index 12f397ff06c..b9804b1b6db 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt
+++ b/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);
diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js
index 5a61d4d5d7e..4765d1de283 100644
--- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js
+++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js
@@ -1,4 +1,5 @@
 //// [constructorWithIncompleteTypeAnnotation.ts]
+
 declare module "fs" {
     export class File {
         constructor(filename: string);
diff --git a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt
index 1c80f7057b8..dec899c7218 100644
--- a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt
+++ b/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 = () => {
diff --git a/tests/baselines/reference/continueNotInIterationStatement4.js b/tests/baselines/reference/continueNotInIterationStatement4.js
index f3f52ecb48c..50261be23b1 100644
--- a/tests/baselines/reference/continueNotInIterationStatement4.js
+++ b/tests/baselines/reference/continueNotInIterationStatement4.js
@@ -1,4 +1,5 @@
 //// [continueNotInIterationStatement4.ts]
+
 TWO:
 while (true){
   var x = () => {
diff --git a/tests/baselines/reference/continueTarget3.js b/tests/baselines/reference/continueTarget3.js
index 052b7b593c3..70c2d2590e5 100644
--- a/tests/baselines/reference/continueTarget3.js
+++ b/tests/baselines/reference/continueTarget3.js
@@ -1,4 +1,5 @@
 //// [continueTarget3.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/continueTarget3.symbols b/tests/baselines/reference/continueTarget3.symbols
index a1b930f2f5a..a5decfe16d1 100644
--- a/tests/baselines/reference/continueTarget3.symbols
+++ b/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;
diff --git a/tests/baselines/reference/continueTarget3.types b/tests/baselines/reference/continueTarget3.types
index 3336b47772c..d55f1c3f6d2 100644
--- a/tests/baselines/reference/continueTarget3.types
+++ b/tests/baselines/reference/continueTarget3.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/continueTarget3.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/continueTarget4.js b/tests/baselines/reference/continueTarget4.js
index 0f6211f9202..23c20a03260 100644
--- a/tests/baselines/reference/continueTarget4.js
+++ b/tests/baselines/reference/continueTarget4.js
@@ -1,4 +1,5 @@
 //// [continueTarget4.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/continueTarget4.symbols b/tests/baselines/reference/continueTarget4.symbols
index ea1989a3e4d..fc69a881a60 100644
--- a/tests/baselines/reference/continueTarget4.symbols
+++ b/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;
diff --git a/tests/baselines/reference/continueTarget4.types b/tests/baselines/reference/continueTarget4.types
index 5d2b7c29bbe..e3e3ae82dfe 100644
--- a/tests/baselines/reference/continueTarget4.types
+++ b/tests/baselines/reference/continueTarget4.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/continueTarget4.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/continueTarget5.errors.txt b/tests/baselines/reference/continueTarget5.errors.txt
index 401c5874ee0..854f57017b6 100644
--- a/tests/baselines/reference/continueTarget5.errors.txt
+++ b/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() {
diff --git a/tests/baselines/reference/continueTarget5.js b/tests/baselines/reference/continueTarget5.js
index 5bf309d2690..030a1c2589c 100644
--- a/tests/baselines/reference/continueTarget5.js
+++ b/tests/baselines/reference/continueTarget5.js
@@ -1,4 +1,5 @@
 //// [continueTarget5.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.js b/tests/baselines/reference/declarationEmitDetachedComment1.js
new file mode 100644
index 00000000000..38c7e60406d
--- /dev/null
+++ b/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 {
+}
diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.symbols b/tests/baselines/reference/declarationEmitDetachedComment1.symbols
new file mode 100644
index 00000000000..c466716ca44
--- /dev/null
+++ b/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))
+
+}
+
diff --git a/tests/baselines/reference/declarationEmitDetachedComment1.types b/tests/baselines/reference/declarationEmitDetachedComment1.types
new file mode 100644
index 00000000000..6d1a87b5151
--- /dev/null
+++ b/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
+
+}
+
diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.js b/tests/baselines/reference/declarationEmitDetachedComment2.js
new file mode 100644
index 00000000000..d4d176da12c
--- /dev/null
+++ b/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 {
+}
diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.symbols b/tests/baselines/reference/declarationEmitDetachedComment2.symbols
new file mode 100644
index 00000000000..c466716ca44
--- /dev/null
+++ b/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))
+
+}
+
diff --git a/tests/baselines/reference/declarationEmitDetachedComment2.types b/tests/baselines/reference/declarationEmitDetachedComment2.types
new file mode 100644
index 00000000000..6d1a87b5151
--- /dev/null
+++ b/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
+
+}
+
diff --git a/tests/baselines/reference/declarationFiles.errors.txt b/tests/baselines/reference/declarationFiles.errors.txt
index c55cac9000b..bbd65b6d658 100644
--- a/tests/baselines/reference/declarationFiles.errors.txt
+++ b/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 {
diff --git a/tests/baselines/reference/doWhileBreakStatements.js b/tests/baselines/reference/doWhileBreakStatements.js
index a2bc0d3c549..8e272ceed0a 100644
--- a/tests/baselines/reference/doWhileBreakStatements.js
+++ b/tests/baselines/reference/doWhileBreakStatements.js
@@ -1,4 +1,5 @@
 //// [doWhileBreakStatements.ts]
+
 do {
     break;
 } while(true)
diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols
index 7d9db9a5ebb..14db540598d 100644
--- a/tests/baselines/reference/doWhileBreakStatements.symbols
+++ b/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)
diff --git a/tests/baselines/reference/doWhileBreakStatements.types b/tests/baselines/reference/doWhileBreakStatements.types
index c3ca932910a..f143cb17d08 100644
--- a/tests/baselines/reference/doWhileBreakStatements.types
+++ b/tests/baselines/reference/doWhileBreakStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts ===
+
 do {
     break;
 } while(true)
diff --git a/tests/baselines/reference/doWhileContinueStatements.js b/tests/baselines/reference/doWhileContinueStatements.js
index 7f73157fd99..51bac3c4e09 100644
--- a/tests/baselines/reference/doWhileContinueStatements.js
+++ b/tests/baselines/reference/doWhileContinueStatements.js
@@ -1,4 +1,5 @@
 //// [doWhileContinueStatements.ts]
+
 do {
     continue;
 } while(true)
diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols
index e4c6d577d5a..36ca2dde764 100644
--- a/tests/baselines/reference/doWhileContinueStatements.symbols
+++ b/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)
diff --git a/tests/baselines/reference/doWhileContinueStatements.types b/tests/baselines/reference/doWhileContinueStatements.types
index 90c9f59842a..e4d3191d040 100644
--- a/tests/baselines/reference/doWhileContinueStatements.types
+++ b/tests/baselines/reference/doWhileContinueStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts ===
+
 do {
     continue;
 } while(true)
diff --git a/tests/baselines/reference/downlevelLetConst16.errors.txt b/tests/baselines/reference/downlevelLetConst16.errors.txt
index 905d1a607e8..a6ada633016 100644
--- a/tests/baselines/reference/downlevelLetConst16.errors.txt
+++ b/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);
diff --git a/tests/baselines/reference/downlevelLetConst16.js b/tests/baselines/reference/downlevelLetConst16.js
index 874fc121191..d6f05f7584a 100644
--- a/tests/baselines/reference/downlevelLetConst16.js
+++ b/tests/baselines/reference/downlevelLetConst16.js
@@ -1,4 +1,5 @@
 //// [downlevelLetConst16.ts]
+
 'use strict'
 
 declare function use(a: any);
diff --git a/tests/baselines/reference/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt
deleted file mode 100644
index 066c75abeb1..00000000000
--- a/tests/baselines/reference/downlevelLetConst18.errors.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-tests/cases/compiler/downlevelLetConst18.ts(4,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(8,14): error TS2393: Duplicate function implementation.
-
-
-==== tests/cases/compiler/downlevelLetConst18.ts (2 errors) ====
-    'use strict'
-    
-    for (let x; ;) {
-        function foo() { x };
-                 ~~~
-!!! error TS2393: Duplicate function implementation.
-    }
-    
-    for (let x; ;) {
-        function foo() { x };
-                 ~~~
-!!! error TS2393: Duplicate function implementation.
-    }
-    
-    for (let x; ;) {
-        (() => { x })();
-    }
-    
-    for (const x = 1; ;) {
-        (() => { x })();
-    }
-    
-    for (let x; ;) {
-        ({ foo() { x }})
-    }
-    
-    for (let x; ;) {
-        ({ get foo() { return x } })
-    }
-    
-    for (let x; ;) {
-        ({ set foo(v) { x } })
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/downlevelLetConst18.js b/tests/baselines/reference/downlevelLetConst18.js
index 59bd316f8a3..cc11c1eef3a 100644
--- a/tests/baselines/reference/downlevelLetConst18.js
+++ b/tests/baselines/reference/downlevelLetConst18.js
@@ -1,4 +1,5 @@
 //// [downlevelLetConst18.ts]
+
 'use strict'
 
 for (let x; ;) {
@@ -6,7 +7,7 @@ for (let x; ;) {
 }
 
 for (let x; ;) {
-    function foo() { x };
+    function foo1() { x };
 }
 
 for (let x; ;) {
@@ -40,7 +41,7 @@ for (var x = void 0;;) {
     _loop_1(x);
 }
 var _loop_2 = function(x) {
-    function foo() { x; }
+    function foo1() { x; }
     ;
 };
 for (var x = void 0;;) {
diff --git a/tests/baselines/reference/downlevelLetConst18.symbols b/tests/baselines/reference/downlevelLetConst18.symbols
new file mode 100644
index 00000000000..a1df0dc6ae9
--- /dev/null
+++ b/tests/baselines/reference/downlevelLetConst18.symbols
@@ -0,0 +1,59 @@
+=== tests/cases/compiler/downlevelLetConst18.ts ===
+
+'use strict'
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 3, 8))
+
+    function foo() { x };
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 3, 16))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 3, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 7, 8))
+
+    function foo1() { x };
+>foo1 : Symbol(foo1, Decl(downlevelLetConst18.ts, 7, 16))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 7, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 11, 8))
+
+    (() => { x })();
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 11, 8))
+}
+
+for (const x = 1; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 15, 10))
+
+    (() => { x })();
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 15, 10))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 19, 8))
+
+    ({ foo() { x }})
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 20, 6))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 19, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 23, 8))
+
+    ({ get foo() { return x } })
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 24, 6))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 23, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 27, 8))
+
+    ({ set foo(v) { x } })
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 28, 6))
+>v : Symbol(v, Decl(downlevelLetConst18.ts, 28, 15))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 27, 8))
+}
+
diff --git a/tests/baselines/reference/downlevelLetConst18.types b/tests/baselines/reference/downlevelLetConst18.types
new file mode 100644
index 00000000000..42421aa80c0
--- /dev/null
+++ b/tests/baselines/reference/downlevelLetConst18.types
@@ -0,0 +1,73 @@
+=== tests/cases/compiler/downlevelLetConst18.ts ===
+
+'use strict'
+>'use strict' : string
+
+for (let x; ;) {
+>x : any
+
+    function foo() { x };
+>foo : () => void
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    function foo1() { x };
+>foo1 : () => void
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    (() => { x })();
+>(() => { x })() : void
+>(() => { x }) : () => void
+>() => { x } : () => void
+>x : any
+}
+
+for (const x = 1; ;) {
+>x : number
+>1 : number
+
+    (() => { x })();
+>(() => { x })() : void
+>(() => { x }) : () => void
+>() => { x } : () => void
+>x : number
+}
+
+for (let x; ;) {
+>x : any
+
+    ({ foo() { x }})
+>({ foo() { x }}) : { foo(): void; }
+>{ foo() { x }} : { foo(): void; }
+>foo : () => void
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    ({ get foo() { return x } })
+>({ get foo() { return x } }) : { foo: any; }
+>{ get foo() { return x } } : { foo: any; }
+>foo : any
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    ({ set foo(v) { x } })
+>({ set foo(v) { x } }) : { foo: any; }
+>{ set foo(v) { x } } : { foo: any; }
+>foo : any
+>v : any
+>x : any
+}
+
diff --git a/tests/baselines/reference/duplicateLabel1.errors.txt b/tests/baselines/reference/duplicateLabel1.errors.txt
index b34f1f771e0..cf116f656fc 100644
--- a/tests/baselines/reference/duplicateLabel1.errors.txt
+++ b/tests/baselines/reference/duplicateLabel1.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target'
+tests/cases/compiler/duplicateLabel1.ts(3,1): error TS1114: Duplicate label 'target'
 
 
 ==== tests/cases/compiler/duplicateLabel1.ts (1 errors) ====
+    
     target:
     target:
     ~~~~~~
diff --git a/tests/baselines/reference/duplicateLabel1.js b/tests/baselines/reference/duplicateLabel1.js
index e7976895c94..5251cec3e36 100644
--- a/tests/baselines/reference/duplicateLabel1.js
+++ b/tests/baselines/reference/duplicateLabel1.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel1.ts]
+
 target:
 target:
 while (true) {
diff --git a/tests/baselines/reference/duplicateLabel2.errors.txt b/tests/baselines/reference/duplicateLabel2.errors.txt
index 307596cf4e8..2a87ed96648 100644
--- a/tests/baselines/reference/duplicateLabel2.errors.txt
+++ b/tests/baselines/reference/duplicateLabel2.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target'
+tests/cases/compiler/duplicateLabel2.ts(4,3): error TS1114: Duplicate label 'target'
 
 
 ==== tests/cases/compiler/duplicateLabel2.ts (1 errors) ====
+    
     target:
     while (true) {
       target:
diff --git a/tests/baselines/reference/duplicateLabel2.js b/tests/baselines/reference/duplicateLabel2.js
index 9ee9671d59d..40a5ee4595e 100644
--- a/tests/baselines/reference/duplicateLabel2.js
+++ b/tests/baselines/reference/duplicateLabel2.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel2.ts]
+
 target:
 while (true) {
   target:
diff --git a/tests/baselines/reference/duplicateLabel3.js b/tests/baselines/reference/duplicateLabel3.js
index 37e9619e8f6..a1d33e46fc1 100644
--- a/tests/baselines/reference/duplicateLabel3.js
+++ b/tests/baselines/reference/duplicateLabel3.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel3.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/duplicateLabel3.symbols b/tests/baselines/reference/duplicateLabel3.symbols
index 07d0ded2923..89f2d5ee48a 100644
--- a/tests/baselines/reference/duplicateLabel3.symbols
+++ b/tests/baselines/reference/duplicateLabel3.symbols
@@ -1,8 +1,9 @@
 === tests/cases/compiler/duplicateLabel3.ts ===
+
 target:
 while (true) {
   function f() {
->f : Symbol(f, Decl(duplicateLabel3.ts, 1, 14))
+>f : Symbol(f, Decl(duplicateLabel3.ts, 2, 14))
 
     target:
     while (true) {
diff --git a/tests/baselines/reference/duplicateLabel3.types b/tests/baselines/reference/duplicateLabel3.types
index 8d75b08c768..920a077aa9e 100644
--- a/tests/baselines/reference/duplicateLabel3.types
+++ b/tests/baselines/reference/duplicateLabel3.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/duplicateLabel3.ts ===
+
 target:
 >target : any
 
diff --git a/tests/baselines/reference/duplicateLabel4.js b/tests/baselines/reference/duplicateLabel4.js
index 22d072d38d7..d5b81b1e5bb 100644
--- a/tests/baselines/reference/duplicateLabel4.js
+++ b/tests/baselines/reference/duplicateLabel4.js
@@ -1,4 +1,5 @@
 //// [duplicateLabel4.ts]
+
 target:
 while (true) {
 }
diff --git a/tests/baselines/reference/duplicateLabel4.symbols b/tests/baselines/reference/duplicateLabel4.symbols
index c671abcef35..5660782e2ec 100644
--- a/tests/baselines/reference/duplicateLabel4.symbols
+++ b/tests/baselines/reference/duplicateLabel4.symbols
@@ -1,5 +1,6 @@
 === tests/cases/compiler/duplicateLabel4.ts ===
-target:
+
+No type information for this code.target:
 No type information for this code.while (true) {
 No type information for this code.}
 No type information for this code.
diff --git a/tests/baselines/reference/duplicateLabel4.types b/tests/baselines/reference/duplicateLabel4.types
index 9238986b582..a10a06fe7a2 100644
--- a/tests/baselines/reference/duplicateLabel4.types
+++ b/tests/baselines/reference/duplicateLabel4.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/duplicateLabel4.ts ===
+
 target:
 >target : any
 
diff --git a/tests/baselines/reference/duplicateLocalVariable1.errors.txt b/tests/baselines/reference/duplicateLocalVariable1.errors.txt
index e4217d4d411..bd6d535d88e 100644
--- a/tests/baselines/reference/duplicateLocalVariable1.errors.txt
+++ b/tests/baselines/reference/duplicateLocalVariable1.errors.txt
@@ -1,7 +1,19 @@
-tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequent variable declarations must have the same type.  Variable 'i' must be of type 'any', but here has type 'number'.
+tests/cases/compiler/duplicateLocalVariable1.ts(2,4): error TS1005: ';' expected.
+tests/cases/compiler/duplicateLocalVariable1.ts(2,11): error TS1146: Declaration expected.
+tests/cases/compiler/duplicateLocalVariable1.ts(2,13): error TS2304: Cannot find name 'commonjs'.
+tests/cases/compiler/duplicateLocalVariable1.ts(12,14): error TS1148: Cannot compile modules unless the '--module' flag is provided.
+tests/cases/compiler/duplicateLocalVariable1.ts(187,22): error TS2403: Subsequent variable declarations must have the same type.  Variable 'i' must be of type 'any', but here has type 'number'.
 
 
-==== tests/cases/compiler/duplicateLocalVariable1.ts (1 errors) ====
+==== tests/cases/compiler/duplicateLocalVariable1.ts (5 errors) ====
+    
+    / /@module: commonjs
+       ~
+!!! error TS1005: ';' expected.
+              
+!!! error TS1146: Declaration expected.
+                ~~~~~~~~
+!!! error TS2304: Cannot find name 'commonjs'.
     
     //import FileManager = require('filemanager');
     //import App = require('app');
@@ -12,6 +24,8 @@ tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequen
     var TestFileDir = ".\\TempTestFiles";
     
     export class TestCase {
+                 ~~~~~~~~
+!!! error TS1148: Cannot compile modules unless the '--module' flag is provided.
         constructor (public name: string, public test: ()=>boolean, public errorMessageRegEx?: string) {
         }
     }
diff --git a/tests/baselines/reference/duplicateLocalVariable1.js b/tests/baselines/reference/duplicateLocalVariable1.js
index 62e291f28c0..ecde1ff2407 100644
--- a/tests/baselines/reference/duplicateLocalVariable1.js
+++ b/tests/baselines/reference/duplicateLocalVariable1.js
@@ -1,5 +1,7 @@
 //// [duplicateLocalVariable1.ts]
 
+/ /@module: commonjs
+
 //import FileManager = require('filemanager');
 //import App = require('app');
 
@@ -344,8 +346,8 @@ export var tests: TestRunner = (function () {
 })();
 
 //// [duplicateLocalVariable1.js]
-//import FileManager = require('filemanager');
-//import App = require('app');
+/ /;
+commonjs;
 var TestFileDir = ".\\TempTestFiles";
 var TestCase = (function () {
     function TestCase(name, test, errorMessageRegEx) {
diff --git a/tests/baselines/reference/duplicateVariablesByScope.js b/tests/baselines/reference/duplicateVariablesByScope.js
index d87fd966f32..43b6e89d412 100644
--- a/tests/baselines/reference/duplicateVariablesByScope.js
+++ b/tests/baselines/reference/duplicateVariablesByScope.js
@@ -1,4 +1,5 @@
 //// [duplicateVariablesByScope.ts]
+
 // duplicate local variables are only reported at global scope
 
 module M {
diff --git a/tests/baselines/reference/duplicateVariablesByScope.symbols b/tests/baselines/reference/duplicateVariablesByScope.symbols
index bc94dc9b807..9dd280d2756 100644
--- a/tests/baselines/reference/duplicateVariablesByScope.symbols
+++ b/tests/baselines/reference/duplicateVariablesByScope.symbols
@@ -1,56 +1,57 @@
 === tests/cases/compiler/duplicateVariablesByScope.ts ===
+
 // duplicate local variables are only reported at global scope
 
 module M {
 >M : Symbol(M, Decl(duplicateVariablesByScope.ts, 0, 0))
 
     for (var j = 0; j < 10; j++) {
->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12))
->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12))
->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
     }
 
     for (var j = 0; j < 10; j++) {
->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12))
->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12))
->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
+>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12))
     }
 }
 
 function foo() {
->foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 8, 1))
+>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 9, 1))
 
     var x = 2;
->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7))
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7))
 
     var x = 1;
->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7))
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7))
 
     if (true) {
         var result = 1;
->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11))
+>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11))
     }
     else {
         var result = 2;
->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11))
+>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11))
     }
 }
 
 class C {
->C : Symbol(C, Decl(duplicateVariablesByScope.ts, 19, 1))
+>C : Symbol(C, Decl(duplicateVariablesByScope.ts, 20, 1))
 
     foo() {
->foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 21, 9))
+>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 22, 9))
 
         try {
             var x = 1;
->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15))
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15))
         }
         catch (e) {
->e : Symbol(e, Decl(duplicateVariablesByScope.ts, 26, 15))
+>e : Symbol(e, Decl(duplicateVariablesByScope.ts, 27, 15))
 
             var x = 2;
->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15))
+>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15))
         }
     }
 }
diff --git a/tests/baselines/reference/duplicateVariablesByScope.types b/tests/baselines/reference/duplicateVariablesByScope.types
index 42d8cae2a3c..30e68d921ca 100644
--- a/tests/baselines/reference/duplicateVariablesByScope.types
+++ b/tests/baselines/reference/duplicateVariablesByScope.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/duplicateVariablesByScope.ts ===
+
 // duplicate local variables are only reported at global scope
 
 module M {
diff --git a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js
index 11c4f4e1807..52207ceda96 100644
--- a/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js
+++ b/tests/baselines/reference/emptyVariableDeclarationBindingPatterns01_ES5.js
@@ -80,22 +80,22 @@
 })();
 (function () {
     var ns = [];
-    for (var _i = 0; _i < ns.length; _i++) {
-        var _a = ns[_i];
+    for (var _i = 0, ns_1 = ns; _i < ns_1.length; _i++) {
+        var _a = ns_1[_i];
     }
-    for (var _b = 0; _b < ns.length; _b++) {
-        var _c = ns[_b];
+    for (var _b = 0, ns_2 = ns; _b < ns_2.length; _b++) {
+        var _c = ns_2[_b];
     }
-    for (var _d = 0; _d < ns.length; _d++) {
-        var _e = ns[_d];
+    for (var _d = 0, ns_3 = ns; _d < ns_3.length; _d++) {
+        var _e = ns_3[_d];
     }
-    for (var _f = 0; _f < ns.length; _f++) {
-        var _g = ns[_f];
+    for (var _f = 0, ns_4 = ns; _f < ns_4.length; _f++) {
+        var _g = ns_4[_f];
     }
-    for (var _h = 0; _h < ns.length; _h++) {
-        var _j = ns[_h];
+    for (var _h = 0, ns_5 = ns; _h < ns_5.length; _h++) {
+        var _j = ns_5[_h];
     }
-    for (var _k = 0; _k < ns.length; _k++) {
-        var _l = ns[_k];
+    for (var _k = 0, ns_6 = ns; _k < ns_6.length; _k++) {
+        var _l = ns_6[_k];
     }
 })();
diff --git a/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt b/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt
index 5b66a377307..403e79b8742 100644
--- a/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt
+++ b/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt
@@ -1,6 +1,6 @@
 tests/cases/compiler/errorOnContextuallyTypedReturnType.ts(1,5): error TS2322: Type '() => void' is not assignable to type '() => boolean'.
   Type 'void' is not assignable to type 'boolean'.
-tests/cases/compiler/errorOnContextuallyTypedReturnType.ts(2,37): 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/errorOnContextuallyTypedReturnType.ts(2,37): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 
 
 ==== tests/cases/compiler/errorOnContextuallyTypedReturnType.ts (2 errors) ====
@@ -10,5 +10,5 @@ tests/cases/compiler/errorOnContextuallyTypedReturnType.ts(2,37): error TS2355:
 !!! error TS2322:   Type 'void' is not assignable to type 'boolean'.
     var n2: () => boolean = function ():boolean { }; // expect an error here
                                         ~~~~~~~
-!!! 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.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.js b/tests/baselines/reference/es6ClassSuperCodegenBug.js
index 62c96f6260d..9f15af96be8 100644
--- a/tests/baselines/reference/es6ClassSuperCodegenBug.js
+++ b/tests/baselines/reference/es6ClassSuperCodegenBug.js
@@ -1,4 +1,5 @@
 //// [es6ClassSuperCodegenBug.ts]
+
 class A {
 	constructor(str1:string, str2:string) {}
 }
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols
index d520ec3ceb1..bb500a1d2c2 100644
--- a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols
+++ b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols
@@ -1,13 +1,14 @@
 === tests/cases/compiler/es6ClassSuperCodegenBug.ts ===
+
 class A {
 >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0))
 
 	constructor(str1:string, str2:string) {}
->str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 1, 13))
->str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 1, 25))
+>str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 2, 13))
+>str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 2, 25))
 }
 class B extends A {
->B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 2, 1))
+>B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 3, 1))
 >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0))
 
     constructor() {
diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.types b/tests/baselines/reference/es6ClassSuperCodegenBug.types
index bdf8ebde8f2..65269c99997 100644
--- a/tests/baselines/reference/es6ClassSuperCodegenBug.types
+++ b/tests/baselines/reference/es6ClassSuperCodegenBug.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/es6ClassSuperCodegenBug.ts ===
+
 class A {
 >A : A
 
diff --git a/tests/baselines/reference/escapedIdentifiers.js b/tests/baselines/reference/escapedIdentifiers.js
index 5ab7dcc5a5a..64eaaa5784f 100644
--- a/tests/baselines/reference/escapedIdentifiers.js
+++ b/tests/baselines/reference/escapedIdentifiers.js
@@ -1,4 +1,5 @@
 //// [escapedIdentifiers.ts]
+
 /*
     0 .. \u0030
     9 .. \u0039
diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols
index 6c84b25647f..a99e067b898 100644
--- a/tests/baselines/reference/escapedIdentifiers.symbols
+++ b/tests/baselines/reference/escapedIdentifiers.symbols
@@ -1,4 +1,5 @@
 === tests/cases/compiler/escapedIdentifiers.ts ===
+
 /*
     0 .. \u0030
     9 .. \u0039
@@ -12,222 +13,222 @@
 
 // var decl
 var \u0061 = 1;
->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3))
+>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3))
 
 a ++;
->a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3))
+>a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3))
 
 \u0061 ++;
->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3))
+>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3))
 
 var b = 1;
->b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3))
+>b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3))
 
 b ++;
->b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3))
+>b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3))
 
 \u0062 ++;
->\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3))
+>\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3))
 
 // modules
 module moduleType1 { 
->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10))
+>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10))
 
     export var baz1: number;
->baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 22, 14))
+>baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 23, 14))
 }
 module moduleType\u0032 { 
->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1))
+>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1))
 
     export var baz2: number;
->baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 25, 14))
+>baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 26, 14))
 }
 
 moduleType1.baz1 = 3;
->moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14))
->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10))
->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14))
+>moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
+>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10))
+>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
 
 moduleType\u0031.baz1 = 3;
->moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14))
->moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10))
->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14))
+>moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
+>moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10))
+>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14))
 
 moduleType2.baz2 = 3;
->moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14))
->moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1))
->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14))
+>moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
+>moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1))
+>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
 
 moduleType\u0032.baz2 = 3;
->moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14))
->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1))
->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14))
+>moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
+>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1))
+>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14))
 
 // classes
 
 class classType1 { 
->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26))
+>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26))
 
     public foo1: number;
->foo1 : Symbol(foo1, Decl(escapedIdentifiers.ts, 35, 18))
+>foo1 : Symbol(foo1, Decl(escapedIdentifiers.ts, 36, 18))
 }
 class classType\u0032 { 
->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1))
+>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1))
 
     public foo2: number;
->foo2 : Symbol(foo2, Decl(escapedIdentifiers.ts, 38, 23))
+>foo2 : Symbol(foo2, Decl(escapedIdentifiers.ts, 39, 23))
 }
 
 var classType1Object1 = new classType1();
->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3))
->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26))
+>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3))
+>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26))
 
 classType1Object1.foo1 = 2;
->classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18))
->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3))
->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18))
+>classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
+>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3))
+>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
 
 var classType1Object2 = new classType\u0031();
->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3))
->classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26))
+>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3))
+>classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26))
 
 classType1Object2.foo1 = 2;
->classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18))
->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3))
->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18))
+>classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
+>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3))
+>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18))
 
 var classType2Object1 = new classType2();
->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3))
->classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1))
+>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3))
+>classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1))
 
 classType2Object1.foo2 = 2;
->classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23))
->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3))
->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23))
+>classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
+>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3))
+>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
 
 var classType2Object2 = new classType\u0032();
->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3))
->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1))
+>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3))
+>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1))
 
 classType2Object2.foo2 = 2;
->classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23))
->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3))
->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23))
+>classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
+>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3))
+>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23))
 
 // interfaces
 interface interfaceType1 { 
->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
+>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27))
 
     bar1: number;
->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 52, 26))
+>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 53, 26))
 }
 interface interfaceType\u0032 { 
->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
+>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1))
 
     bar2: number;
->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 55, 31))
+>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 56, 31))
 }
 
 var interfaceType1Object1 = <interfaceType1>{ bar1: 0 };
->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3))
->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 59, 45))
+>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3))
+>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27))
+>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 60, 45))
 
 interfaceType1Object1.bar1 = 2;
->interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26))
->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3))
->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26))
+>interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
+>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3))
+>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
 
 var interfaceType1Object2 = <interfaceType\u0031>{ bar1: 0 };
->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3))
->interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27))
->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 61, 50))
+>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3))
+>interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27))
+>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 62, 50))
 
 interfaceType1Object2.bar1 = 2;
->interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26))
->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3))
->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26))
+>interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
+>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3))
+>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26))
 
 var interfaceType2Object1 = <interfaceType2>{ bar2: 0 };
->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3))
->interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 63, 45))
+>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3))
+>interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1))
+>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 64, 45))
 
 interfaceType2Object1.bar2 = 2;
->interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31))
->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3))
->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31))
+>interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
+>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3))
+>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
 
 var interfaceType2Object2 = <interfaceType\u0032>{ bar2: 0 };
->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3))
->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1))
->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 65, 50))
+>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3))
+>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1))
+>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 66, 50))
 
 interfaceType2Object2.bar2 = 2;
->interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31))
->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3))
->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31))
+>interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
+>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3))
+>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31))
 
 
 // arguments
 class testClass { 
->testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 66, 31))
+>testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 67, 31))
 
     public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { 
->func : Symbol(func, Decl(escapedIdentifiers.ts, 70, 17))
->arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16))
->arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29))
->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48))
->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68))
+>func : Symbol(func, Decl(escapedIdentifiers.ts, 71, 17))
+>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16))
+>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29))
+>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48))
+>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68))
 
         arg\u0031 = 1;
->arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16))
+>arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16))
 
         arg2 = 'string';
->arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29))
+>arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29))
 
         arg\u0033 = true;
->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48))
+>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48))
 
         arg4 = 2;
->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68))
+>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68))
     }
 }
 
 // constructors
 class constructorTestClass { 
->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1))
+>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1))
 
     constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { 
->arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 81, 17))
->arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 81, 37))
->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 81, 62))
->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 81, 88))
+>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 82, 17))
+>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 82, 37))
+>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 82, 62))
+>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 82, 88))
     }
 }
 var constructorTestObject = new constructorTestClass(1, 'string', true, 2);
->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3))
->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1))
 
 constructorTestObject.arg\u0031 = 1;
->constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17))
->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3))
->arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17))
+>constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17))
 
 constructorTestObject.arg2 = 'string';
->constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37))
->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3))
->arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37))
+>constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37))
 
 constructorTestObject.arg\u0033 = true;
->constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62))
->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3))
->arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62))
+>constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62))
 
 constructorTestObject.arg4 = 2;
->constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88))
->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3))
->arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88))
+>constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88))
+>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3))
+>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88))
 
 // Lables
 
diff --git a/tests/baselines/reference/escapedIdentifiers.types b/tests/baselines/reference/escapedIdentifiers.types
index b32d21a48cb..67713976bd6 100644
--- a/tests/baselines/reference/escapedIdentifiers.types
+++ b/tests/baselines/reference/escapedIdentifiers.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/escapedIdentifiers.ts ===
+
 /*
     0 .. \u0030
     9 .. \u0039
diff --git a/tests/baselines/reference/for.errors.txt b/tests/baselines/reference/for.errors.txt
index 41ed5765c9a..d2caefbcdae 100644
--- a/tests/baselines/reference/for.errors.txt
+++ b/tests/baselines/reference/for.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/for.ts(29,6): error TS1109: Expression expected.
+tests/cases/compiler/for.ts(30,6): error TS1109: Expression expected.
 
 
 ==== tests/cases/compiler/for.ts (1 errors) ====
+    
     for (var i = 0; i < 10; i++) { // ok
         var x1 = i;
     }
diff --git a/tests/baselines/reference/for.js b/tests/baselines/reference/for.js
index a77b68d8b6e..857d42bafdb 100644
--- a/tests/baselines/reference/for.js
+++ b/tests/baselines/reference/for.js
@@ -1,4 +1,5 @@
 //// [for.ts]
+
 for (var i = 0; i < 10; i++) { // ok
     var x1 = i;
 }
diff --git a/tests/baselines/reference/forBreakStatements.js b/tests/baselines/reference/forBreakStatements.js
index 9ed65627c9c..da4fccdfd2a 100644
--- a/tests/baselines/reference/forBreakStatements.js
+++ b/tests/baselines/reference/forBreakStatements.js
@@ -1,4 +1,5 @@
 //// [forBreakStatements.ts]
+
 for (; ;) {
     break;
 }
diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols
index 76db9309a39..6d869b45934 100644
--- a/tests/baselines/reference/forBreakStatements.symbols
+++ b/tests/baselines/reference/forBreakStatements.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts ===
+
 for (; ;) {
     break;
 }
@@ -33,7 +34,7 @@ for (; ;) for (; ;) for (; ;) break SEVEN;
 EIGHT:
 for (; ;) {
     var fn = function () { }
->fn : Symbol(fn, Decl(forBreakStatements.ts, 33, 7))
+>fn : Symbol(fn, Decl(forBreakStatements.ts, 34, 7))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/forBreakStatements.types b/tests/baselines/reference/forBreakStatements.types
index 8469a85bd19..c494f6be30a 100644
--- a/tests/baselines/reference/forBreakStatements.types
+++ b/tests/baselines/reference/forBreakStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts ===
+
 for (; ;) {
     break;
 }
diff --git a/tests/baselines/reference/forContinueStatements.js b/tests/baselines/reference/forContinueStatements.js
index 34f70bb1fc1..fc5aa0434b3 100644
--- a/tests/baselines/reference/forContinueStatements.js
+++ b/tests/baselines/reference/forContinueStatements.js
@@ -1,4 +1,5 @@
 //// [forContinueStatements.ts]
+
 for (; ;) {
     continue;
 }
diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols
index e24eb2aaa92..9e0c396acfb 100644
--- a/tests/baselines/reference/forContinueStatements.symbols
+++ b/tests/baselines/reference/forContinueStatements.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts ===
+
 for (; ;) {
     continue;
 }
@@ -33,7 +34,7 @@ for (; ;) for (; ;) for (; ;) continue SEVEN;
 EIGHT:
 for (; ;) {
     var fn = function () { }
->fn : Symbol(fn, Decl(forContinueStatements.ts, 33, 7))
+>fn : Symbol(fn, Decl(forContinueStatements.ts, 34, 7))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/forContinueStatements.types b/tests/baselines/reference/forContinueStatements.types
index 79b78e83345..0b52bdd5d47 100644
--- a/tests/baselines/reference/forContinueStatements.types
+++ b/tests/baselines/reference/forContinueStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts ===
+
 for (; ;) {
     continue;
 }
diff --git a/tests/baselines/reference/forInBreakStatements.js b/tests/baselines/reference/forInBreakStatements.js
index 24b7cc57b8d..ebbadb31277 100644
--- a/tests/baselines/reference/forInBreakStatements.js
+++ b/tests/baselines/reference/forInBreakStatements.js
@@ -1,4 +1,5 @@
 //// [forInBreakStatements.ts]
+
 for(var x in {}) {
     break;
 }
diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols
index 7984edc3fd6..5f48e110835 100644
--- a/tests/baselines/reference/forInBreakStatements.symbols
+++ b/tests/baselines/reference/forInBreakStatements.symbols
@@ -1,13 +1,14 @@
 === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts ===
+
 for(var x in {}) {
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
     break;
 }
 
 ONE:
 for(var x in {}) {
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
     break ONE;
 }
@@ -15,43 +16,43 @@ for(var x in {}) {
 TWO:
 THREE:
 for(var x in {}) {
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
     break THREE;
 }
 
 FOUR:
 for(var x in {}) {
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
     FIVE:
     for(var x in {}) {
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
         break FOUR;
     }
 }
 
 for(var x in {}) {
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
     SIX:
     for(var x in {}) break SIX;
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 }
 
 SEVEN:
 for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN;
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
 EIGHT:
 for (var x in {}){
->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8))
 
     var fn = function () { }
->fn : Symbol(fn, Decl(forInBreakStatements.ts, 33, 7))
+>fn : Symbol(fn, Decl(forInBreakStatements.ts, 34, 7))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/forInBreakStatements.types b/tests/baselines/reference/forInBreakStatements.types
index 05ea8e35feb..7714429e5af 100644
--- a/tests/baselines/reference/forInBreakStatements.types
+++ b/tests/baselines/reference/forInBreakStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts ===
+
 for(var x in {}) {
 >x : any
 >{} : {}
diff --git a/tests/baselines/reference/forInContinueStatements.js b/tests/baselines/reference/forInContinueStatements.js
index 8b036c59721..ca530dd5d6c 100644
--- a/tests/baselines/reference/forInContinueStatements.js
+++ b/tests/baselines/reference/forInContinueStatements.js
@@ -1,4 +1,5 @@
 //// [forInContinueStatements.ts]
+
 for(var x in {}) {
     continue;
 }
diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols
index 88129a50d21..a0edea53f3e 100644
--- a/tests/baselines/reference/forInContinueStatements.symbols
+++ b/tests/baselines/reference/forInContinueStatements.symbols
@@ -1,13 +1,14 @@
 === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts ===
+
 for(var x in {}) {
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
     continue;
 }
 
 ONE:
 for(var x in {}) {
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
     continue ONE;
 }
@@ -15,43 +16,43 @@ for(var x in {}) {
 TWO:
 THREE:
 for(var x in {}) {
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
     continue THREE;
 }
 
 FOUR:
 for(var x in {}) {
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
     FIVE:
     for(var x in {}) {
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
         continue FOUR;
     }
 }
 
 for(var x in {}) {
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
     SIX:
     for(var x in {}) continue SIX;
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 }
 
 SEVEN:
 for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN;
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
 EIGHT:
 for (var x in {}){
->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8))
+>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8))
 
     var fn = function () { }
->fn : Symbol(fn, Decl(forInContinueStatements.ts, 33, 7))
+>fn : Symbol(fn, Decl(forInContinueStatements.ts, 34, 7))
 
     continue EIGHT;
 }
diff --git a/tests/baselines/reference/forInContinueStatements.types b/tests/baselines/reference/forInContinueStatements.types
index 95637345fa6..572fd16053d 100644
--- a/tests/baselines/reference/forInContinueStatements.types
+++ b/tests/baselines/reference/forInContinueStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts ===
+
 for(var x in {}) {
 >x : any
 >{} : {}
diff --git a/tests/baselines/reference/forStatements.js b/tests/baselines/reference/forStatements.js
index 39fdb6c8871..253fafc81e8 100644
--- a/tests/baselines/reference/forStatements.js
+++ b/tests/baselines/reference/forStatements.js
@@ -1,4 +1,5 @@
 //// [forStatements.ts]
+
 interface I {
     id: number;
 }
diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols
index e72d55e5813..2d5250217f9 100644
--- a/tests/baselines/reference/forStatements.symbols
+++ b/tests/baselines/reference/forStatements.symbols
@@ -1,145 +1,146 @@
 === tests/cases/conformance/statements/forStatements/forStatements.ts ===
+
 interface I {
 >I : Symbol(I, Decl(forStatements.ts, 0, 0))
 
     id: number;
->id : Symbol(id, Decl(forStatements.ts, 0, 13))
+>id : Symbol(id, Decl(forStatements.ts, 1, 13))
 }
 
 class C implements I {
->C : Symbol(C, Decl(forStatements.ts, 2, 1))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
 >I : Symbol(I, Decl(forStatements.ts, 0, 0))
 
     id: number;
->id : Symbol(id, Decl(forStatements.ts, 4, 22))
+>id : Symbol(id, Decl(forStatements.ts, 5, 22))
 }
 
 class D<T>{
->D : Symbol(D, Decl(forStatements.ts, 6, 1))
->T : Symbol(T, Decl(forStatements.ts, 8, 8))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
 
     source: T;
->source : Symbol(source, Decl(forStatements.ts, 8, 11))
->T : Symbol(T, Decl(forStatements.ts, 8, 8))
+>source : Symbol(source, Decl(forStatements.ts, 9, 11))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
 
     recurse: D<T>;
->recurse : Symbol(recurse, Decl(forStatements.ts, 9, 14))
->D : Symbol(D, Decl(forStatements.ts, 6, 1))
->T : Symbol(T, Decl(forStatements.ts, 8, 8))
+>recurse : Symbol(recurse, Decl(forStatements.ts, 10, 14))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
 
     wrapped: D<D<T>>
->wrapped : Symbol(wrapped, Decl(forStatements.ts, 10, 18))
->D : Symbol(D, Decl(forStatements.ts, 6, 1))
->D : Symbol(D, Decl(forStatements.ts, 6, 1))
->T : Symbol(T, Decl(forStatements.ts, 8, 8))
+>wrapped : Symbol(wrapped, Decl(forStatements.ts, 11, 18))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>T : Symbol(T, Decl(forStatements.ts, 9, 8))
 }
 
 function F(x: string): number { return 42; }
->F : Symbol(F, Decl(forStatements.ts, 12, 1))
->x : Symbol(x, Decl(forStatements.ts, 14, 11))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+>x : Symbol(x, Decl(forStatements.ts, 15, 11))
 
 module M {
->M : Symbol(M, Decl(forStatements.ts, 14, 44))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
 
     export class A {
->A : Symbol(A, Decl(forStatements.ts, 16, 10))
+>A : Symbol(A, Decl(forStatements.ts, 17, 10))
 
         name: string;
->name : Symbol(name, Decl(forStatements.ts, 17, 20))
+>name : Symbol(name, Decl(forStatements.ts, 18, 20))
     }
 
     export function F2(x: number): string { return x.toString(); }
->F2 : Symbol(F2, Decl(forStatements.ts, 19, 5))
->x : Symbol(x, Decl(forStatements.ts, 21, 23))
+>F2 : Symbol(F2, Decl(forStatements.ts, 20, 5))
+>x : Symbol(x, Decl(forStatements.ts, 22, 23))
 >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(forStatements.ts, 21, 23))
+>x : Symbol(x, Decl(forStatements.ts, 22, 23))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 for(var aNumber: number = 9.9;;){} 
->aNumber : Symbol(aNumber, Decl(forStatements.ts, 24, 7))
+>aNumber : Symbol(aNumber, Decl(forStatements.ts, 25, 7))
 
 for(var aString: string = 'this is a string';;){}
->aString : Symbol(aString, Decl(forStatements.ts, 25, 7))
+>aString : Symbol(aString, Decl(forStatements.ts, 26, 7))
 
 for(var aDate: Date = new Date(12);;){}
->aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7))
+>aDate : Symbol(aDate, Decl(forStatements.ts, 27, 7))
 >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for(var anObject: Object = new Object();;){}
->anObject : Symbol(anObject, Decl(forStatements.ts, 27, 7))
+>anObject : Symbol(anObject, Decl(forStatements.ts, 28, 7))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for(var anAny: any = null;;){}
->anAny : Symbol(anAny, Decl(forStatements.ts, 29, 7))
+>anAny : Symbol(anAny, Decl(forStatements.ts, 30, 7))
 
 for(var aSecondAny: any = undefined;;){}
->aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 30, 7))
+>aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 31, 7))
 >undefined : Symbol(undefined)
 
 for(var aVoid: void = undefined;;){}
->aVoid : Symbol(aVoid, Decl(forStatements.ts, 31, 7))
+>aVoid : Symbol(aVoid, Decl(forStatements.ts, 32, 7))
 >undefined : Symbol(undefined)
 
 for(var anInterface: I = new C();;){}
->anInterface : Symbol(anInterface, Decl(forStatements.ts, 33, 7))
+>anInterface : Symbol(anInterface, Decl(forStatements.ts, 34, 7))
 >I : Symbol(I, Decl(forStatements.ts, 0, 0))
->C : Symbol(C, Decl(forStatements.ts, 2, 1))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
 
 for(var aClass: C = new C();;){}
->aClass : Symbol(aClass, Decl(forStatements.ts, 34, 7))
->C : Symbol(C, Decl(forStatements.ts, 2, 1))
->C : Symbol(C, Decl(forStatements.ts, 2, 1))
+>aClass : Symbol(aClass, Decl(forStatements.ts, 35, 7))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
 
 for(var aGenericClass: D<string> = new D<string>();;){}
->aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 35, 7))
->D : Symbol(D, Decl(forStatements.ts, 6, 1))
->D : Symbol(D, Decl(forStatements.ts, 6, 1))
+>aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 36, 7))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
+>D : Symbol(D, Decl(forStatements.ts, 7, 1))
 
 for(var anObjectLiteral: I = { id: 12 };;){}
->anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 36, 7))
+>anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 37, 7))
 >I : Symbol(I, Decl(forStatements.ts, 0, 0))
->id : Symbol(id, Decl(forStatements.ts, 36, 30))
+>id : Symbol(id, Decl(forStatements.ts, 37, 30))
 
 for(var anOtherObjectLiteral: { id: number } = new C();;){}
->anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 37, 7))
->id : Symbol(id, Decl(forStatements.ts, 37, 31))
->C : Symbol(C, Decl(forStatements.ts, 2, 1))
+>anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 38, 7))
+>id : Symbol(id, Decl(forStatements.ts, 38, 31))
+>C : Symbol(C, Decl(forStatements.ts, 3, 1))
 
 for(var aFunction: typeof F = F;;){}
->aFunction : Symbol(aFunction, Decl(forStatements.ts, 39, 7))
->F : Symbol(F, Decl(forStatements.ts, 12, 1))
->F : Symbol(F, Decl(forStatements.ts, 12, 1))
+>aFunction : Symbol(aFunction, Decl(forStatements.ts, 40, 7))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
 
 for(var anOtherFunction: (x: string) => number = F;;){}
->anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 40, 7))
->x : Symbol(x, Decl(forStatements.ts, 40, 26))
->F : Symbol(F, Decl(forStatements.ts, 12, 1))
+>anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 41, 7))
+>x : Symbol(x, Decl(forStatements.ts, 41, 26))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
 
 for(var aLambda: typeof F = (x) => 2;;){}
->aLambda : Symbol(aLambda, Decl(forStatements.ts, 41, 7))
->F : Symbol(F, Decl(forStatements.ts, 12, 1))
->x : Symbol(x, Decl(forStatements.ts, 41, 29))
+>aLambda : Symbol(aLambda, Decl(forStatements.ts, 42, 7))
+>F : Symbol(F, Decl(forStatements.ts, 13, 1))
+>x : Symbol(x, Decl(forStatements.ts, 42, 29))
 
 for(var aModule: typeof M = M;;){}
->aModule : Symbol(aModule, Decl(forStatements.ts, 43, 7))
->M : Symbol(M, Decl(forStatements.ts, 14, 44))
->M : Symbol(M, Decl(forStatements.ts, 14, 44))
+>aModule : Symbol(aModule, Decl(forStatements.ts, 44, 7))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
 
 for(var aClassInModule: M.A = new M.A();;){}
->aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 44, 7))
->M : Symbol(M, Decl(forStatements.ts, 14, 44))
->A : Symbol(M.A, Decl(forStatements.ts, 16, 10))
->M.A : Symbol(M.A, Decl(forStatements.ts, 16, 10))
->M : Symbol(M, Decl(forStatements.ts, 14, 44))
->A : Symbol(M.A, Decl(forStatements.ts, 16, 10))
+>aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 45, 7))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>A : Symbol(M.A, Decl(forStatements.ts, 17, 10))
+>M.A : Symbol(M.A, Decl(forStatements.ts, 17, 10))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>A : Symbol(M.A, Decl(forStatements.ts, 17, 10))
 
 for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){}
->aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 45, 7))
->M.F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5))
->M : Symbol(M, Decl(forStatements.ts, 14, 44))
->F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5))
->x : Symbol(x, Decl(forStatements.ts, 45, 42))
+>aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 46, 7))
+>M.F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5))
+>M : Symbol(M, Decl(forStatements.ts, 15, 44))
+>F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5))
+>x : Symbol(x, Decl(forStatements.ts, 46, 42))
 
diff --git a/tests/baselines/reference/forStatements.types b/tests/baselines/reference/forStatements.types
index 3fbcf2dbfb2..95b198a7fec 100644
--- a/tests/baselines/reference/forStatements.types
+++ b/tests/baselines/reference/forStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/forStatements/forStatements.ts ===
+
 interface I {
 >I : I
 
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
index 53ecb88363d..f1869ae7fca 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
@@ -1,18 +1,19 @@
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(32,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'number'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'string'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'C'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'D<string>'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'typeof M'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(39,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'number'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'string'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'C'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'D<string>'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(37,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'a' must be of type 'any', but here has type 'typeof M'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(41,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(44,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(48,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '(C | D<string>)[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(51,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(54,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
 
 ==== tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts (12 errors) ====
+    
     interface I {
         id: number;
     }
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js
index 1dde9981880..20639c687cb 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js
@@ -1,4 +1,5 @@
 //// [forStatementsMultipleInvalidDecl.ts]
+
 interface I {
     id: number;
 }
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.js b/tests/baselines/reference/forStatementsMultipleValidDecl.js
index e95e37d63ac..6913894a15f 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.js
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.js
@@ -1,4 +1,5 @@
 //// [forStatementsMultipleValidDecl.ts]
+
 // all expected to be valid
 
 for (var x: number; ;) { }
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
index 1f131bb9701..d2d8ac01003 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols
@@ -1,110 +1,111 @@
 === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts ===
+
 // all expected to be valid
 
 for (var x: number; ;) { }
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8))
 
 for (var x = 2; ;) { }
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8))
 
 for (var x = <number>undefined; ;) { }
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8))
 >undefined : Symbol(undefined)
 
 // new declaration space, making redeclaring x as a string valid
 function declSpace() {
->declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 5, 38))
+>declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 6, 38))
 
     for (var x = 'this is a string'; ;) { }
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 8, 12))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 9, 12))
 }
 interface Point { x: number; y: number; }
->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 10, 17))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 10, 28))
+>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 11, 17))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 11, 28))
 
 for (var p: Point; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1))
 
 for (var p = { x: 1, y: 2 }; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 13, 14))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 13, 20))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 14))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 20))
 
 for (var p: Point = { x: 0, y: undefined }; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 21))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 27))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 21))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 27))
 >undefined : Symbol(undefined)
 
 for (var p = { x: 1, y: <number>undefined }; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 14))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 20))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 14))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 20))
 >undefined : Symbol(undefined)
 
 for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 13))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 24))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 41))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 47))
-
-for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 15))
->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 26))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 13))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 24))
 >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41))
 >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47))
+
+for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { }
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 15))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 26))
+>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 41))
+>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 47))
 >undefined : Symbol(undefined)
 
 for (var p: typeof p; ;) { }
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
+>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8))
 
 for (var fn = function (s: string) { return 42; }; ;) { }
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 20, 24))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 24))
 
 for (var fn = (s: string) => 3; ;) { }
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 15))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 15))
 
 for (var fn: (s: string) => number; ;) { }
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 14))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 14))
 
 for (var fn: { (s: string): number }; ;) { }
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 16))
-
-for (var fn = <(s: string) => number> null; ;) { }
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
 >s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16))
 
+for (var fn = <(s: string) => number> null; ;) { }
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 25, 16))
+
 for (var fn: typeof fn; ;) { }
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
+>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8))
 
 for (var a: string[]; ;) { }
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
 
 for (var a = ['a', 'b']; ;) { }
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
 
 for (var a = <string[]>[]; ;) { }
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
 
 for (var a: string[] = []; ;) { }
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
 
 for (var a = new Array<string>(); ;) { }
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 for (var a: typeof a; ;) { }
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
+>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8))
 
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.types b/tests/baselines/reference/forStatementsMultipleValidDecl.types
index 9b9af5b850e..acb26f17312 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.types
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts ===
+
 // all expected to be valid
 
 for (var x: number; ;) { }
diff --git a/tests/baselines/reference/functionImplementationErrors.errors.txt b/tests/baselines/reference/functionImplementationErrors.errors.txt
index 0c74588c316..86ecb6a6057 100644
--- a/tests/baselines/reference/functionImplementationErrors.errors.txt
+++ b/tests/baselines/reference/functionImplementationErrors.errors.txt
@@ -1,20 +1,20 @@
-tests/cases/conformance/functions/functionImplementationErrors.ts(2,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(6,19): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(10,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(16,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(25,16): 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/functions/functionImplementationErrors.ts(30,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
-tests/cases/conformance/functions/functionImplementationErrors.ts(35,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
-tests/cases/conformance/functions/functionImplementationErrors.ts(40,28): 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/functions/functionImplementationErrors.ts(49,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(53,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(57,11): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(61,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(65,11): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(3,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(7,19): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(11,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(17,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(26,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/functions/functionImplementationErrors.ts(31,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
+tests/cases/conformance/functions/functionImplementationErrors.ts(36,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it.
+tests/cases/conformance/functions/functionImplementationErrors.ts(50,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(54,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(58,11): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(62,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(66,11): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/functions/functionImplementationErrors.ts(70,11): error TS2354: No best common type exists among return expressions.
 
 
-==== tests/cases/conformance/functions/functionImplementationErrors.ts (14 errors) ====
+==== tests/cases/conformance/functions/functionImplementationErrors.ts (13 errors) ====
+    
     // FunctionExpression with no return type annotation with multiple return statements with unrelated types
     var f1 = function () {
              ~~~~~~~~
@@ -52,7 +52,7 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error
     // Function implemetnation with non -void return type annotation with no return
     function f5(): number {
                    ~~~~~~
-!!! 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.
     }
     
     var m;
@@ -72,8 +72,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error
     // FunctionExpression with non -void return type annotation with a throw, no return, and other code
     // Should be error but isn't
     undefined === function (): number {
-                               ~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
         throw undefined;
         var x = 4;
     };
diff --git a/tests/baselines/reference/functionImplementationErrors.js b/tests/baselines/reference/functionImplementationErrors.js
index 42be5f21458..4436f1bc94f 100644
--- a/tests/baselines/reference/functionImplementationErrors.js
+++ b/tests/baselines/reference/functionImplementationErrors.js
@@ -1,4 +1,5 @@
 //// [functionImplementationErrors.ts]
+
 // FunctionExpression with no return type annotation with multiple return statements with unrelated types
 var f1 = function () {
     return '';
diff --git a/tests/baselines/reference/functionImplementations.js b/tests/baselines/reference/functionImplementations.js
index 3fc040650e4..512da960b78 100644
--- a/tests/baselines/reference/functionImplementations.js
+++ b/tests/baselines/reference/functionImplementations.js
@@ -1,4 +1,5 @@
 //// [functionImplementations.ts]
+
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 
diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols
index 3932261b27c..07945b5f765 100644
--- a/tests/baselines/reference/functionImplementations.symbols
+++ b/tests/baselines/reference/functionImplementations.symbols
@@ -1,109 +1,110 @@
 === tests/cases/conformance/functions/functionImplementations.ts ===
+
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
->v : Symbol(v, Decl(functionImplementations.ts, 1, 3))
+>v : Symbol(v, Decl(functionImplementations.ts, 2, 3))
 
 // FunctionExpression f with no return type annotation and directly references f in its body returns any
 var a: any = function f() {
->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->f : Symbol(f, Decl(functionImplementations.ts, 4, 12))
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 5, 12))
 
     return f;
->f : Symbol(f, Decl(functionImplementations.ts, 4, 12))
+>f : Symbol(f, Decl(functionImplementations.ts, 5, 12))
 
 };
 var a: any = function f() {
->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->f : Symbol(f, Decl(functionImplementations.ts, 7, 12))
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 8, 12))
 
     return f();
->f : Symbol(f, Decl(functionImplementations.ts, 7, 12))
+>f : Symbol(f, Decl(functionImplementations.ts, 8, 12))
 
 };
 
 // FunctionExpression f with no return type annotation and indirectly references f in its body returns any
 var a: any = function f() {
->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->f : Symbol(f, Decl(functionImplementations.ts, 12, 12))
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 13, 12))
 
     var x = f;
->x : Symbol(x, Decl(functionImplementations.ts, 13, 7))
->f : Symbol(f, Decl(functionImplementations.ts, 12, 12))
+>x : Symbol(x, Decl(functionImplementations.ts, 14, 7))
+>f : Symbol(f, Decl(functionImplementations.ts, 13, 12))
 
     return x;
->x : Symbol(x, Decl(functionImplementations.ts, 13, 7))
+>x : Symbol(x, Decl(functionImplementations.ts, 14, 7))
 
 };
 
 // Two mutually recursive function implementations with no return type annotations
 function rec1() {
->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2))
+>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2))
 
     return rec2();
->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1))
+>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1))
 }
 function rec2() {
->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1))
+>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1))
 
     return rec1();
->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2))
+>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2))
 }
 var a = rec1();
->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2))
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2))
 
 var a = rec2();
->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1))
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1))
 
 // Two mutually recursive function implementations with return type annotation in one
 function rec3(): number {
->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15))
+>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15))
 
     return rec4();
->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1))
+>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1))
 }
 function rec4() {
->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1))
+>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1))
 
     return rec3();
->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15))
+>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15))
 }
 var n: number;
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
 
 var n = rec3();
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15))
 
 var n = rec4();
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1))
 
 // FunctionExpression with no return type annotation and returns a number
 var n = function () {
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
 
     return 3;
 } ();
 
 // FunctionExpression with no return type annotation and returns null
 var nu = null;
->nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3))
+>nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3))
 
 var nu = function () {
->nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3))
+>nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3))
 
     return null;
 } ();
 
 // FunctionExpression with no return type annotation and returns undefined
 var un = undefined;
->un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3))
+>un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3))
 >undefined : Symbol(undefined)
 
 var un = function () {
->un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3))
+>un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3))
 
     return undefined;
 >undefined : Symbol(undefined)
@@ -112,31 +113,31 @@ var un = function () {
 
 // FunctionExpression with no return type annotation and returns a type parameter type
 var n = function <T>(x: T) {
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->T : Symbol(T, Decl(functionImplementations.ts, 56, 18))
->x : Symbol(x, Decl(functionImplementations.ts, 56, 21))
->T : Symbol(T, Decl(functionImplementations.ts, 56, 18))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>T : Symbol(T, Decl(functionImplementations.ts, 57, 18))
+>x : Symbol(x, Decl(functionImplementations.ts, 57, 21))
+>T : Symbol(T, Decl(functionImplementations.ts, 57, 18))
 
     return x;
->x : Symbol(x, Decl(functionImplementations.ts, 56, 21))
+>x : Symbol(x, Decl(functionImplementations.ts, 57, 21))
 
 } (4);
 
 // FunctionExpression with no return type annotation and returns a constrained type parameter type
 var n = function <T extends {}>(x: T) {
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
->T : Symbol(T, Decl(functionImplementations.ts, 61, 18))
->x : Symbol(x, Decl(functionImplementations.ts, 61, 32))
->T : Symbol(T, Decl(functionImplementations.ts, 61, 18))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
+>T : Symbol(T, Decl(functionImplementations.ts, 62, 18))
+>x : Symbol(x, Decl(functionImplementations.ts, 62, 32))
+>T : Symbol(T, Decl(functionImplementations.ts, 62, 18))
 
     return x;
->x : Symbol(x, Decl(functionImplementations.ts, 61, 32))
+>x : Symbol(x, Decl(functionImplementations.ts, 62, 32))
 
 } (4);
 
 // FunctionExpression with no return type annotation with multiple return statements with identical types
 var n = function () {
->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3))
+>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3))
 
     return 3;
     return 5;
@@ -148,36 +149,36 @@ var n = function () {
 // A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others.
 // FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns
 class Base { private m; }
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
->m : Symbol(m, Decl(functionImplementations.ts, 76, 12))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>m : Symbol(m, Decl(functionImplementations.ts, 77, 12))
 
 class Derived extends Base { private q; }
->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25))
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
->q : Symbol(q, Decl(functionImplementations.ts, 77, 28))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>q : Symbol(q, Decl(functionImplementations.ts, 78, 28))
 
 var b: Base;
->b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3))
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
+>b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
 
 var b = function () {
->b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3))
+>b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3))
 
     return new Base(); return new Derived();
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
 
 } ();
 
 // FunctionExpression with no return type annotation with multiple return statements with one a recursive call
 var a = function f() {
->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3))
->f : Symbol(f, Decl(functionImplementations.ts, 84, 7))
+>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3))
+>f : Symbol(f, Decl(functionImplementations.ts, 85, 7))
 
     return new Base(); return new Derived(); return f(); // ?
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25))
->f : Symbol(f, Decl(functionImplementations.ts, 84, 7))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
+>f : Symbol(f, Decl(functionImplementations.ts, 85, 7))
 
 } ();
 
@@ -192,59 +193,59 @@ undefined === function (): number {
 
 // Type of 'this' in function implementation is 'any'
 function thisFunc() {
->thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 91, 2))
+>thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 92, 2))
 
     var x = this;
->x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7))
+>x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7))
 
     var x: any;
->x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7))
+>x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7))
 }
 
 // Function signature with optional parameter, no type annotation and initializer has initializer's type
 function opt1(n = 4) {
->opt1 : Symbol(opt1, Decl(functionImplementations.ts, 97, 1))
->n : Symbol(n, Decl(functionImplementations.ts, 100, 14))
+>opt1 : Symbol(opt1, Decl(functionImplementations.ts, 98, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 101, 14))
 
     var m = n;
->m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7))
->n : Symbol(n, Decl(functionImplementations.ts, 100, 14))
+>m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7))
+>n : Symbol(n, Decl(functionImplementations.ts, 101, 14))
 
     var m: number;
->m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7))
+>m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7))
 }
 
 // Function signature with optional parameter, no type annotation and initializer has initializer's widened type
 function opt2(n = { x: null, y: undefined }) {
->opt2 : Symbol(opt2, Decl(functionImplementations.ts, 103, 1))
->n : Symbol(n, Decl(functionImplementations.ts, 106, 14))
->x : Symbol(x, Decl(functionImplementations.ts, 106, 19))
->y : Symbol(y, Decl(functionImplementations.ts, 106, 28))
+>opt2 : Symbol(opt2, Decl(functionImplementations.ts, 104, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 107, 14))
+>x : Symbol(x, Decl(functionImplementations.ts, 107, 19))
+>y : Symbol(y, Decl(functionImplementations.ts, 107, 28))
 >undefined : Symbol(undefined)
 
     var m = n;
->m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7))
->n : Symbol(n, Decl(functionImplementations.ts, 106, 14))
+>m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7))
+>n : Symbol(n, Decl(functionImplementations.ts, 107, 14))
 
     var m: { x: any; y: any };
->m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7))
->x : Symbol(x, Decl(functionImplementations.ts, 108, 12))
->y : Symbol(y, Decl(functionImplementations.ts, 108, 20))
+>m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7))
+>x : Symbol(x, Decl(functionImplementations.ts, 109, 12))
+>y : Symbol(y, Decl(functionImplementations.ts, 109, 20))
 }
 
 // Function signature with initializer referencing other parameter to the left
 function opt3(n: number, m = n) {
->opt3 : Symbol(opt3, Decl(functionImplementations.ts, 109, 1))
->n : Symbol(n, Decl(functionImplementations.ts, 112, 14))
->m : Symbol(m, Decl(functionImplementations.ts, 112, 24))
->n : Symbol(n, Decl(functionImplementations.ts, 112, 14))
+>opt3 : Symbol(opt3, Decl(functionImplementations.ts, 110, 1))
+>n : Symbol(n, Decl(functionImplementations.ts, 113, 14))
+>m : Symbol(m, Decl(functionImplementations.ts, 113, 24))
+>n : Symbol(n, Decl(functionImplementations.ts, 113, 14))
 
     var y = m;
->y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7))
->m : Symbol(m, Decl(functionImplementations.ts, 112, 24))
+>y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7))
+>m : Symbol(m, Decl(functionImplementations.ts, 113, 24))
 
     var y: number;
->y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7))
+>y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7))
 }
 
 // Function signature with optional parameter has correct codegen 
@@ -252,93 +253,93 @@ function opt3(n: number, m = n) {
 
 // FunctionExpression with non -void return type annotation return with no expression
 function f6(): number {
->f6 : Symbol(f6, Decl(functionImplementations.ts, 115, 1))
+>f6 : Symbol(f6, Decl(functionImplementations.ts, 116, 1))
 
     return;
 }
 
 class Derived2 extends Base { private r: string; }
->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1))
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
->r : Symbol(r, Decl(functionImplementations.ts, 125, 29))
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
+>r : Symbol(r, Decl(functionImplementations.ts, 126, 29))
 
 class AnotherClass { private x }
->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50))
->x : Symbol(x, Decl(functionImplementations.ts, 126, 20))
+>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50))
+>x : Symbol(x, Decl(functionImplementations.ts, 127, 20))
 
 // if f is a contextually typed function expression, the inferred return type is the union type
 // of the types of the return statement expressions in the function body, 
 // ignoring return statements with no expressions.
 var f7: (x: number) => string | number = x => { // should be (x: number) => number | string
->f7 : Symbol(f7, Decl(functionImplementations.ts, 130, 3))
->x : Symbol(x, Decl(functionImplementations.ts, 130, 9))
->x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
+>f7 : Symbol(f7, Decl(functionImplementations.ts, 131, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 9))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
 
     if (x < 0) { return x; }
->x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
->x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
 
     return x.toString();
 >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(functionImplementations.ts, 130, 40))
+>x : Symbol(x, Decl(functionImplementations.ts, 131, 40))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 var f8: (x: number) => any = x => { // should be (x: number) => Base
->f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3))
->x : Symbol(x, Decl(functionImplementations.ts, 134, 9))
->x : Symbol(x, Decl(functionImplementations.ts, 134, 28))
+>f8 : Symbol(f8, Decl(functionImplementations.ts, 135, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 135, 9))
+>x : Symbol(x, Decl(functionImplementations.ts, 135, 28))
 
     return new Base();
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
 
     return new Derived2();
->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1))
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
 }
 var f9: (x: number) => any = x => { // should be (x: number) => Base
->f9 : Symbol(f9, Decl(functionImplementations.ts, 138, 3))
->x : Symbol(x, Decl(functionImplementations.ts, 138, 9))
->x : Symbol(x, Decl(functionImplementations.ts, 138, 28))
+>f9 : Symbol(f9, Decl(functionImplementations.ts, 139, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 139, 9))
+>x : Symbol(x, Decl(functionImplementations.ts, 139, 28))
 
     return new Base();
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
 
     return new Derived();
->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
 
     return new Derived2();
->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1))
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
 }
 var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1
->f10 : Symbol(f10, Decl(functionImplementations.ts, 143, 3))
->x : Symbol(x, Decl(functionImplementations.ts, 143, 10))
->x : Symbol(x, Decl(functionImplementations.ts, 143, 29))
+>f10 : Symbol(f10, Decl(functionImplementations.ts, 144, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 144, 10))
+>x : Symbol(x, Decl(functionImplementations.ts, 144, 29))
 
     return new Derived();
->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25))
+>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25))
 
     return new Derived2();
->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1))
+>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1))
 }
 var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
->f11 : Symbol(f11, Decl(functionImplementations.ts, 147, 3))
->x : Symbol(x, Decl(functionImplementations.ts, 147, 10))
->x : Symbol(x, Decl(functionImplementations.ts, 147, 29))
+>f11 : Symbol(f11, Decl(functionImplementations.ts, 148, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 148, 10))
+>x : Symbol(x, Decl(functionImplementations.ts, 148, 29))
 
     return new Base();
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
 
     return new AnotherClass();
->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50))
+>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50))
 }
 var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass
->f12 : Symbol(f12, Decl(functionImplementations.ts, 151, 3))
->x : Symbol(x, Decl(functionImplementations.ts, 151, 10))
->x : Symbol(x, Decl(functionImplementations.ts, 151, 29))
+>f12 : Symbol(f12, Decl(functionImplementations.ts, 152, 3))
+>x : Symbol(x, Decl(functionImplementations.ts, 152, 10))
+>x : Symbol(x, Decl(functionImplementations.ts, 152, 29))
 
     return new Base();
->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4))
+>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4))
 
     return; // should be ignored
     return new AnotherClass();
->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50))
+>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50))
 }
diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types
index 1398e2974f0..6690ca68c98 100644
--- a/tests/baselines/reference/functionImplementations.types
+++ b/tests/baselines/reference/functionImplementations.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/functions/functionImplementations.ts ===
+
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 >v : void
diff --git a/tests/baselines/reference/functionOverloads12.js b/tests/baselines/reference/functionOverloads12.js
index 4681e43ee5b..8d834e8180f 100644
--- a/tests/baselines/reference/functionOverloads12.js
+++ b/tests/baselines/reference/functionOverloads12.js
@@ -1,4 +1,5 @@
 //// [functionOverloads12.ts]
+
 function foo():string;
 function foo():number;
 function foo():any { if (true) return ""; else return 0;}
diff --git a/tests/baselines/reference/functionOverloads12.symbols b/tests/baselines/reference/functionOverloads12.symbols
index 583e7f5c045..4744f98c9f2 100644
--- a/tests/baselines/reference/functionOverloads12.symbols
+++ b/tests/baselines/reference/functionOverloads12.symbols
@@ -1,10 +1,11 @@
 === tests/cases/compiler/functionOverloads12.ts ===
+
 function foo():string;
->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22))
+>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22))
 
 function foo():number;
->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22))
+>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22))
 
 function foo():any { if (true) return ""; else return 0;}
->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22))
+>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22))
 
diff --git a/tests/baselines/reference/functionOverloads12.types b/tests/baselines/reference/functionOverloads12.types
index 20f5ee5d556..5db8ff68cd4 100644
--- a/tests/baselines/reference/functionOverloads12.types
+++ b/tests/baselines/reference/functionOverloads12.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/functionOverloads12.ts ===
+
 function foo():string;
 >foo : { (): string; (): number; }
 
diff --git a/tests/baselines/reference/functionReturn.js b/tests/baselines/reference/functionReturn.js
index c433eec190d..42d0de5fd7c 100644
--- a/tests/baselines/reference/functionReturn.js
+++ b/tests/baselines/reference/functionReturn.js
@@ -1,4 +1,5 @@
 //// [functionReturn.ts]
+
 function f0(): void { }
 function f1() {
     var n: any = f0();
diff --git a/tests/baselines/reference/functionReturn.symbols b/tests/baselines/reference/functionReturn.symbols
index 9c6b794b3d0..630e435635b 100644
--- a/tests/baselines/reference/functionReturn.symbols
+++ b/tests/baselines/reference/functionReturn.symbols
@@ -1,28 +1,29 @@
 === tests/cases/compiler/functionReturn.ts ===
+
 function f0(): void { }
 >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0))
 
 function f1() {
->f1 : Symbol(f1, Decl(functionReturn.ts, 0, 23))
+>f1 : Symbol(f1, Decl(functionReturn.ts, 1, 23))
 
     var n: any = f0();
->n : Symbol(n, Decl(functionReturn.ts, 2, 7))
+>n : Symbol(n, Decl(functionReturn.ts, 3, 7))
 >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0))
 }
 function f2(): any { }
->f2 : Symbol(f2, Decl(functionReturn.ts, 3, 1))
+>f2 : Symbol(f2, Decl(functionReturn.ts, 4, 1))
 
 function f3(): string { return; }
->f3 : Symbol(f3, Decl(functionReturn.ts, 4, 22))
+>f3 : Symbol(f3, Decl(functionReturn.ts, 5, 22))
 
 function f4(): string {
->f4 : Symbol(f4, Decl(functionReturn.ts, 5, 33))
+>f4 : Symbol(f4, Decl(functionReturn.ts, 6, 33))
 
     return '';
     return;
 }
 function f5(): string {
->f5 : Symbol(f5, Decl(functionReturn.ts, 9, 1))
+>f5 : Symbol(f5, Decl(functionReturn.ts, 10, 1))
 
     return '';
     return undefined;
diff --git a/tests/baselines/reference/functionReturn.types b/tests/baselines/reference/functionReturn.types
index 6fc9d680db9..f9c0b36fbc2 100644
--- a/tests/baselines/reference/functionReturn.types
+++ b/tests/baselines/reference/functionReturn.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/functionReturn.ts ===
+
 function f0(): void { }
 >f0 : () => void
 
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt
index 8a57d8e08e6..a981d337093 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt
@@ -1,15 +1,16 @@
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(4,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(12,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(22,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(31,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(43,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(48,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(5,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(13,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(23,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(32,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(44,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(49,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 
 
 ==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts (9 errors) ====
+    
     // return type of a function with multiple returns is the BCT of each return statement
     // it is an error if there is no single BCT, these are error cases
     
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.js b/tests/baselines/reference/functionWithMultipleReturnStatements.js
index 347a05d0f33..d44c37ebbf0 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements.js
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements.js
@@ -1,4 +1,5 @@
 //// [functionWithMultipleReturnStatements.ts]
+
 // return type of a function with multiple returns is the BCT of each return statement
 // it is an error if there is no single BCT, these are error cases
 
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt
index bbaa5a85578..0399c7a79a6 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(58,10): error TS2354: No best common type exists among return expressions.
-tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(67,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(59,10): error TS2354: No best common type exists among return expressions.
+tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(68,10): error TS2354: No best common type exists among return expressions.
 
 
 ==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts (2 errors) ====
+    
     // return type of a function with multiple returns is the BCT of each return statement
     // no errors expected here
     
diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.js b/tests/baselines/reference/functionWithMultipleReturnStatements2.js
index 4674c6db953..efee5816fb6 100644
--- a/tests/baselines/reference/functionWithMultipleReturnStatements2.js
+++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.js
@@ -1,4 +1,5 @@
 //// [functionWithMultipleReturnStatements2.ts]
+
 // return type of a function with multiple returns is the BCT of each return statement
 // no errors expected here
 
diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt b/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt
index 3c8fef3eb49..86234b7dd81 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt
+++ b/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/functionWithNoBestCommonType1.ts(1,10): error TS2354: No best common type exists among return expressions.
+tests/cases/compiler/functionWithNoBestCommonType1.ts(2,10): error TS2354: No best common type exists among return expressions.
 
 
 ==== tests/cases/compiler/functionWithNoBestCommonType1.ts (1 errors) ====
+    
     function foo() {
              ~~~
 !!! error TS2354: No best common type exists among return expressions.
diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.js b/tests/baselines/reference/functionWithNoBestCommonType1.js
index f7114fb40d8..4d197c24334 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType1.js
+++ b/tests/baselines/reference/functionWithNoBestCommonType1.js
@@ -1,4 +1,5 @@
 //// [functionWithNoBestCommonType1.ts]
+
 function foo() {
     return true;
     return bar();
diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt b/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt
index 981e330d9b5..6ce898e447c 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt
+++ b/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/functionWithNoBestCommonType2.ts(1,9): error TS2354: No best common type exists among return expressions.
+tests/cases/compiler/functionWithNoBestCommonType2.ts(2,9): error TS2354: No best common type exists among return expressions.
 
 
 ==== tests/cases/compiler/functionWithNoBestCommonType2.ts (1 errors) ====
+    
     var v = function () {
             ~~~~~~~~
 !!! error TS2354: No best common type exists among return expressions.
diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.js b/tests/baselines/reference/functionWithNoBestCommonType2.js
index 8e903518ec0..06a133b2db8 100644
--- a/tests/baselines/reference/functionWithNoBestCommonType2.js
+++ b/tests/baselines/reference/functionWithNoBestCommonType2.js
@@ -1,4 +1,5 @@
 //// [functionWithNoBestCommonType2.ts]
+
 var v = function () {
    return true;
    return bar();
diff --git a/tests/baselines/reference/functionWithThrowButNoReturn1.errors.txt b/tests/baselines/reference/functionWithThrowButNoReturn1.errors.txt
deleted file mode 100644
index 72f45da8d97..00000000000
--- a/tests/baselines/reference/functionWithThrowButNoReturn1.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/compiler/functionWithThrowButNoReturn1.ts(1,16): 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/functionWithThrowButNoReturn1.ts (1 errors) ====
-    function fn(): number {
-                   ~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
-      throw new Error('NYI');
-      var t;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/functionWithThrowButNoReturn1.symbols b/tests/baselines/reference/functionWithThrowButNoReturn1.symbols
new file mode 100644
index 00000000000..ebc67c6f466
--- /dev/null
+++ b/tests/baselines/reference/functionWithThrowButNoReturn1.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/functionWithThrowButNoReturn1.ts ===
+function fn(): number {
+>fn : Symbol(fn, Decl(functionWithThrowButNoReturn1.ts, 0, 0))
+
+  throw new Error('NYI');
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+  var t;
+>t : Symbol(t, Decl(functionWithThrowButNoReturn1.ts, 2, 5))
+}
+
diff --git a/tests/baselines/reference/functionWithThrowButNoReturn1.types b/tests/baselines/reference/functionWithThrowButNoReturn1.types
new file mode 100644
index 00000000000..c136d8a4076
--- /dev/null
+++ b/tests/baselines/reference/functionWithThrowButNoReturn1.types
@@ -0,0 +1,13 @@
+=== tests/cases/compiler/functionWithThrowButNoReturn1.ts ===
+function fn(): number {
+>fn : () => number
+
+  throw new Error('NYI');
+>new Error('NYI') : Error
+>Error : ErrorConstructor
+>'NYI' : string
+
+  var t;
+>t : any
+}
+
diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
index 2c5ff15f863..58ffd051d4d 100644
--- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
+++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt
@@ -1,15 +1,14 @@
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(2,16): 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/functionsMissingReturnStatementsAndExpressions.ts(64,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/functionsMissingReturnStatementsAndExpressions.ts(94,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(112,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): error TS1003: Identifier expected.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(3,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(95,16): error TS2378: A 'get' accessor must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(118,5): error TS1003: Identifier expected.
 
 
-==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ====
+==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (3 errors) ====
+    
     
     function f1(): string {
                    ~~~~~~
-!!! 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.
         // errors because there are no return statements
     }
     
@@ -72,8 +71,6 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e
     }
     
     function f14(): number {
-                    ~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
         // Not fine, since we can *only* consist of a single throw statement
         // if no return statements are present but we are annotated.
         throw undefined;
@@ -105,7 +102,7 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e
     class C {
         public get m1() {
                    ~~
-!!! 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.
             // Errors; get accessors must return a value.
         }
     
@@ -124,8 +121,6 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e
         }
     
         public get m5() {
-                   ~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
             // Not fine, since we can *only* consist of a single throw statement
             // if no return statements are present but we are a get accessor.
             throw null;
diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js
index 592a03d7158..f76e5342aee 100644
--- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js
+++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js
@@ -1,5 +1,6 @@
 //// [functionsMissingReturnStatementsAndExpressions.ts]
 
+
 function f1(): string {
     // errors because there are no return statements
 }
diff --git a/tests/baselines/reference/generatedContextualTyping.js b/tests/baselines/reference/generatedContextualTyping.js
index 1f7d2b8035f..a867d4b7629 100644
--- a/tests/baselines/reference/generatedContextualTyping.js
+++ b/tests/baselines/reference/generatedContextualTyping.js
@@ -1,4 +1,5 @@
 //// [generatedContextualTyping.ts]
+
 class Base { private p; }
 class Derived1 extends Base { private m; }
 class Derived2 extends Base { private n; }
diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols
index df0bb33e02f..bc50fcc25c6 100644
--- a/tests/baselines/reference/generatedContextualTyping.symbols
+++ b/tests/baselines/reference/generatedContextualTyping.symbols
@@ -1,2831 +1,2832 @@
 === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts ===
+
 class Base { private p; }
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->p : Symbol(p, Decl(generatedContextualTyping.ts, 0, 12))
+>p : Symbol(p, Decl(generatedContextualTyping.ts, 1, 12))
 
 class Derived1 extends Base { private m; }
->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25))
+>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->m : Symbol(m, Decl(generatedContextualTyping.ts, 1, 29))
+>m : Symbol(m, Decl(generatedContextualTyping.ts, 2, 29))
 
 class Derived2 extends Base { private n; }
->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42))
+>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 2, 29))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 29))
 
 interface Genric<T> { func(n: T[]); }
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
->T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 3, 21))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 27))
->T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
+>T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 4, 21))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 4, 27))
+>T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17))
 
 var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
->b : Symbol(b, Decl(generatedContextualTyping.ts, 4, 3))
+>b : Symbol(b, Decl(generatedContextualTyping.ts, 5, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42))
 
 var x1: () => Base[] = () => [d1, d2];
->x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 5, 3))
+>x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 6, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x2: () => Base[] = function() { return [d1, d2] };
->x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 6, 3))
+>x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 7, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x3: () => Base[] = function named() { return [d1, d2] };
->x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 7, 3))
+>x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 8, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 8, 22))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x4: { (): Base[]; } = () => [d1, d2];
->x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 8, 3))
+>x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 9, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x5: { (): Base[]; } = function() { return [d1, d2] };
->x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 9, 3))
+>x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 10, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x6: { (): Base[]; } = function named() { return [d1, d2] };
->x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 10, 3))
+>x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 11, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 11, 25))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x7: Base[] = [d1, d2];
->x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 11, 3))
+>x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 12, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x8: Array<Base> = [d1, d2];
->x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 12, 3))
+>x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 13, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x9: { [n: number]: Base; } = [d1, d2];
->x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 13, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 13, 11))
+>x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 14, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x10: {n: Base[]; }  = { n: [d1, d2] };
->x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 14, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 10))
+>x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 15, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 10))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 27))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 27))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x11: (s: Base[]) => any = n => { var n: Base[]; return null; };
->x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 15, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 15, 10))
+>x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 16, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 16, 10))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
->x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 16, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 17, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 16, 25))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 31))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 17, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 17, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x13 { member: () => Base[] = () => [d1, d2] }
->x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 16, 60))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 17, 11))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x14 { member: () => Base[] = function() { return [d1, d2] } }
->x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 17, 51))
+>x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 17, 60))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 18, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x15 { member: () => Base[] = function named() { return [d1, d2] } }
->x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 18, 67))
+class x14 { member: () => Base[] = function() { return [d1, d2] } }
+>x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 18, 51))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 19, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x16 { member: { (): Base[]; } = () => [d1, d2] }
->x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 19, 73))
+class x15 { member: () => Base[] = function named() { return [d1, d2] } }
+>x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 19, 67))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 20, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 20, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
->x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 20, 54))
+class x16 { member: { (): Base[]; } = () => [d1, d2] }
+>x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 20, 73))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 21, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
->x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 21, 70))
+class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
+>x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 21, 54))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 22, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x19 { member: Base[] = [d1, d2] }
->x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 22, 76))
+class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 22, 70))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 23, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 23, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x19 { member: Base[] = [d1, d2] }
+>x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 23, 76))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x20 { member: Array<Base> = [d1, d2] }
->x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 23, 39))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11))
+>x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 24, 39))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 25, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x21 { member: { [n: number]: Base; } = [d1, d2] }
->x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 24, 44))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 25, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 25, 23))
+>x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 25, 44))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 23))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
->x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 25, 55))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 21))
+>x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 26, 55))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 38))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
->x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 26, 54))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 27, 21))
+>x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 27, 54))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 28, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
->x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 27, 79))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 28, 79))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 28, 36))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 29, 36))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 29, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x25 { private member: () => Base[] = () => [d1, d2] }
->x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 28, 72))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x26 { private member: () => Base[] = function() { return [d1, d2] } }
->x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 29, 59))
+>x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 29, 72))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 30, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x27 { private member: () => Base[] = function named() { return [d1, d2] } }
->x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 30, 75))
+class x26 { private member: () => Base[] = function() { return [d1, d2] } }
+>x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 30, 59))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 31, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x28 { private member: { (): Base[]; } = () => [d1, d2] }
->x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 31, 81))
+class x27 { private member: () => Base[] = function named() { return [d1, d2] } }
+>x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 31, 75))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 32, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 32, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
->x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 32, 62))
+class x28 { private member: { (): Base[]; } = () => [d1, d2] }
+>x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 32, 81))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 33, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } }
->x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 33, 78))
+class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
+>x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 33, 62))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 34, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x31 { private member: Base[] = [d1, d2] }
->x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 34, 84))
+class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 34, 78))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 35, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 35, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x31 { private member: Base[] = [d1, d2] }
+>x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 35, 84))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x32 { private member: Array<Base> = [d1, d2] }
->x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 35, 47))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11))
+>x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 36, 47))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 37, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x33 { private member: { [n: number]: Base; } = [d1, d2] }
->x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 36, 52))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 37, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 37, 31))
+>x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 37, 52))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
->x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 37, 63))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 29))
+>x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 38, 63))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 46))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
->x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 38, 62))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 39, 29))
+>x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 39, 62))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 40, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
->x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 39, 87))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 40, 87))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 40, 44))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 50))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 41, 44))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 41, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x37 { public member: () => Base[] = () => [d1, d2] }
->x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 40, 80))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x38 { public member: () => Base[] = function() { return [d1, d2] } }
->x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 41, 58))
+>x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 41, 80))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 42, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
->x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 42, 74))
+class x38 { public member: () => Base[] = function() { return [d1, d2] } }
+>x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 42, 58))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 43, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x40 { public member: { (): Base[]; } = () => [d1, d2] }
->x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 43, 80))
+class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
+>x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 43, 74))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 44, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 44, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
->x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 44, 61))
+class x40 { public member: { (): Base[]; } = () => [d1, d2] }
+>x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 44, 80))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 45, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } }
->x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 45, 77))
+class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
+>x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 45, 61))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 46, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x43 { public member: Base[] = [d1, d2] }
->x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 46, 83))
+class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } }
+>x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 46, 77))
 >member : Symbol(member, Decl(generatedContextualTyping.ts, 47, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 47, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x43 { public member: Base[] = [d1, d2] }
+>x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 47, 83))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x44 { public member: Array<Base> = [d1, d2] }
->x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 47, 46))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11))
+>x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 48, 46))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 49, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x45 { public member: { [n: number]: Base; } = [d1, d2] }
->x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 48, 51))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 49, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 49, 30))
+>x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 49, 51))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 30))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
->x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 49, 62))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 28))
+>x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 50, 62))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
->x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 50, 61))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 51, 28))
+>x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 51, 61))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 52, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
->x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 51, 86))
->member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 52, 86))
+>member : Symbol(member, Decl(generatedContextualTyping.ts, 53, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 52, 43))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 49))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 53, 43))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 53, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x49 { static member: () => Base[] = () => [d1, d2] }
->x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 52, 79))
->member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 53, 11))
+>x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 53, 79))
+>member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 54, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x50 { static member: () => Base[] = function() { return [d1, d2] } }
->x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 53, 58))
->member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 54, 11))
+>x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 54, 58))
+>member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 55, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
->x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 54, 74))
->member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 55, 11))
+>x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 55, 74))
+>member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 56, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 56, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x52 { static member: { (): Base[]; } = () => [d1, d2] }
->x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 55, 80))
->member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 56, 11))
+>x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 56, 80))
+>member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 57, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
->x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 56, 61))
->member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 57, 11))
+>x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 57, 61))
+>member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 58, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } }
->x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 57, 77))
->member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 58, 11))
+>x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 58, 77))
+>member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 59, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 59, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x55 { static member: Base[] = [d1, d2] }
->x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 58, 83))
->member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 59, 11))
+>x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 59, 83))
+>member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 60, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x56 { static member: Array<Base> = [d1, d2] }
->x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 59, 46))
->member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 60, 11))
+>x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 60, 46))
+>member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 61, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x57 { static member: { [n: number]: Base; } = [d1, d2] }
->x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 60, 51))
->member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 61, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 61, 30))
+>x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 61, 51))
+>member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 62, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 30))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
->x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 61, 62))
->member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 62, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 28))
+>x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 62, 62))
+>member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 63, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
->x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 62, 61))
->member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 63, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 63, 28))
+>x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 63, 61))
+>member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 64, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 64, 28))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
->x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 63, 86))
->member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 64, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 64, 86))
+>member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 65, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 64, 43))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 49))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 65, 43))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 65, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x61 { private static member: () => Base[] = () => [d1, d2] }
->x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 64, 79))
->member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 65, 11))
+>x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 65, 79))
+>member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 66, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x62 { private static member: () => Base[] = function() { return [d1, d2] } }
->x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 65, 66))
->member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 66, 11))
+>x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 66, 66))
+>member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 67, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x63 { private static member: () => Base[] = function named() { return [d1, d2] } }
->x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 66, 82))
->member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 67, 11))
+>x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 67, 82))
+>member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 68, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 68, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
->x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 67, 88))
->member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 68, 11))
+>x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 68, 88))
+>member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 69, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } }
->x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 68, 69))
->member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 69, 11))
+>x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 69, 69))
+>member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 70, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } }
->x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 69, 85))
->member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 70, 11))
+>x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 70, 85))
+>member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 71, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 71, 52))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x67 { private static member: Base[] = [d1, d2] }
->x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 70, 91))
->member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 71, 11))
+>x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 71, 91))
+>member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 72, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x68 { private static member: Array<Base> = [d1, d2] }
->x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 71, 54))
->member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 72, 11))
+>x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 72, 54))
+>member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 73, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x69 { private static member: { [n: number]: Base; } = [d1, d2] }
->x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 72, 59))
->member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 73, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 73, 38))
+>x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 73, 59))
+>member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 74, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 38))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
->x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 73, 70))
->member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 74, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 36))
+>x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 74, 70))
+>member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 75, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 36))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 53))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
->x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 74, 69))
->member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 75, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 75, 36))
+>x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 75, 69))
+>member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 76, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 76, 36))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
->x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 75, 94))
->member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 76, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 76, 94))
+>member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 77, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 76, 51))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 57))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 77, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 77, 57))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x73 { public static member: () => Base[] = () => [d1, d2] }
->x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 76, 87))
->member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 77, 11))
+>x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 77, 87))
+>member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 78, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x74 { public static member: () => Base[] = function() { return [d1, d2] } }
->x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 77, 65))
->member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 78, 11))
+>x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 78, 65))
+>member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 79, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x75 { public static member: () => Base[] = function named() { return [d1, d2] } }
->x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 78, 81))
->member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 79, 11))
+>x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 79, 81))
+>member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 80, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 80, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
->x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 79, 87))
->member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 80, 11))
+>x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 80, 87))
+>member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 81, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } }
->x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 80, 68))
->member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 81, 11))
+>x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 81, 68))
+>member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 82, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } }
->x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 81, 84))
->member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 82, 11))
+>x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 82, 84))
+>member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 83, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 83, 51))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x79 { public static member: Base[] = [d1, d2] }
->x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 82, 90))
->member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 83, 11))
+>x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 83, 90))
+>member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 84, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x80 { public static member: Array<Base> = [d1, d2] }
->x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 83, 53))
->member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 84, 11))
+>x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 84, 53))
+>member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 85, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x81 { public static member: { [n: number]: Base; } = [d1, d2] }
->x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 84, 58))
->member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 85, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 85, 37))
+>x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 85, 58))
+>member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 86, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 37))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
->x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 85, 69))
->member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 86, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 35))
+>x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 86, 69))
+>member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 87, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 35))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 52))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 52))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } }
->x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 86, 68))
->member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 87, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 87, 35))
+>x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 87, 68))
+>member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 88, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 88, 35))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
->x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 87, 93))
->member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 88, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 88, 93))
+>member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 89, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 88, 50))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 56))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 89, 50))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 89, 56))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
->x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 88, 86))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 89, 24))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } }
->x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 89, 66))
+>x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 89, 86))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } }
->x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 90, 82))
+class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 90, 66))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
->x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 91, 88))
+class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 91, 82))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 92, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
->x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 92, 69))
+class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 92, 88))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
->x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 93, 85))
+class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 93, 69))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x91 { constructor(parm: Base[] = [d1, d2]) { } }
->x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 94, 91))
+class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 94, 85))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 95, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x91 { constructor(parm: Base[] = [d1, d2]) { } }
+>x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 95, 91))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
->x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 95, 54))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24))
+>x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 96, 54))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } }
->x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 96, 59))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 97, 33))
+>x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 97, 59))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 33))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
->x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 97, 70))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 31))
+>x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 98, 70))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 48))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
->x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 98, 69))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 99, 31))
+>x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 99, 69))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 100, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
->x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 99, 94))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 100, 94))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 100, 46))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 52))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 101, 46))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 101, 52))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
->x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 100, 87))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } }
->x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 101, 73))
+>x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 101, 87))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 102, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } }
->x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 102, 89))
+class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 102, 73))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 103, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 103, 89))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 104, 51))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
->x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 103, 95))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 25))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
->x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 104, 77))
+>x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 104, 95))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 105, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
->x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 105, 93))
+class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 105, 77))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 106, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
->x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 106, 99))
+class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 106, 93))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 107, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 107, 55))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
+>x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 107, 99))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
->x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 107, 62))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25))
+>x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 108, 62))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 109, 25))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } }
->x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 108, 67))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 109, 25))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 109, 41))
+>x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 109, 67))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 41))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
->x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 109, 78))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 39))
+>x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 110, 78))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 39))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 56))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 56))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
->x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 110, 77))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 111, 39))
+>x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 111, 77))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 112, 39))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
->x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 111, 102))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 112, 102))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 112, 54))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 60))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 113, 54))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 113, 60))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
->x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 112, 95))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } }
->x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 113, 75))
+>x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 113, 95))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 114, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } }
->x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 114, 91))
+class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } }
+>x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 114, 75))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 115, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
->x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 115, 97))
+class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } }
+>x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 115, 91))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 116, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 116, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
->x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 116, 78))
+class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
+>x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 116, 97))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 117, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
->x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 117, 94))
+class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } }
+>x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 117, 78))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 118, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
->x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 118, 100))
+class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } }
+>x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 118, 94))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 119, 25))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 119, 56))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
+>x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 119, 100))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
->x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 119, 63))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25))
+>x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 120, 63))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 121, 25))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } }
->x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 120, 68))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 121, 25))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 121, 42))
+>x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 121, 68))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
->x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 121, 79))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 40))
+>x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 122, 79))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 57))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 57))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } }
->x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 122, 78))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 123, 40))
+>x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 123, 78))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 124, 40))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { } }
->x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 123, 103))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 124, 103))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 25))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 124, 55))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 61))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 125, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 125, 61))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x121(parm: () => Base[] = () => [d1, d2]) { }
->x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 124, 96))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 14))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
->x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 125, 54))
+>x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 125, 96))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
->x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 126, 70))
+function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
+>x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 126, 54))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
->x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 127, 76))
+function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
+>x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 127, 70))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 128, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
->x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 128, 57))
+function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
+>x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 128, 76))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
->x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 129, 73))
+function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
+>x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 129, 57))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x127(parm: Base[] = [d1, d2]) { }
->x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 130, 79))
+function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
+>x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 130, 73))
 >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 131, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x127(parm: Base[] = [d1, d2]) { }
+>x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 131, 79))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x128(parm: Array<Base> = [d1, d2]) { }
->x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 131, 42))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14))
+>x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 132, 42))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
->x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 132, 47))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 133, 23))
+>x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 133, 47))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 23))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
->x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 133, 58))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 21))
+>x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 134, 58))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 38))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { }
->x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 134, 57))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 135, 21))
+>x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 135, 57))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 136, 21))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
->x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 135, 82))
->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 136, 82))
+>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 137, 14))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 136, 36))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 137, 36))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 137, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x133(): () => Base[] { return () => [d1, d2]; }
->x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 136, 75))
+>x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 137, 75))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x134(): () => Base[] { return function() { return [d1, d2] }; }
->x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 137, 56))
+>x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 138, 56))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x135(): () => Base[] { return function named() { return [d1, d2] }; }
->x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 138, 72))
+>x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 139, 72))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 140, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x136(): { (): Base[]; } { return () => [d1, d2]; }
->x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 139, 78))
+>x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 140, 78))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
->x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 140, 59))
+>x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 141, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
->x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 141, 75))
+>x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 142, 75))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 143, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x139(): Base[] { return [d1, d2]; }
->x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 142, 81))
+>x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 143, 81))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x140(): Array<Base> { return [d1, d2]; }
->x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 143, 44))
+>x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 144, 44))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x141(): { [n: number]: Base; } { return [d1, d2]; }
->x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 144, 49))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 145, 20))
+>x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 145, 49))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
->x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 145, 60))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 18))
+>x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 146, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; }
->x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 146, 59))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 147, 18))
+>x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 147, 59))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 148, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
->x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 147, 84))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 148, 84))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 148, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 46))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 149, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 149, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
->x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 148, 77))
+>x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 149, 77))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
->x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 149, 79))
+>x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 150, 79))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
->x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 150, 111))
+>x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 151, 111))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 83))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
->x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 151, 123))
+>x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 152, 123))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
->x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 152, 82))
+>x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 153, 82))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
->x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 153, 114))
+>x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 154, 114))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 86))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
->x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 154, 126))
+>x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 155, 126))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
->x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 155, 61))
+>x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 156, 61))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
->x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 156, 66))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 157, 20))
+>x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 157, 66))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }; }
->x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 157, 77))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 18))
+>x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 158, 77))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 66))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 66))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; }
->x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 158, 83))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 159, 18))
+>x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 159, 83))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 160, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; }
->x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 159, 129))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 160, 129))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 46))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 84))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 90))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 84))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 90))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x157: () => () => Base[] = () => { return () => [d1, d2]; };
->x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 161, 3))
+>x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 162, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
->x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 162, 3))
+>x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 163, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
->x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 163, 3))
+>x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 164, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 164, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
->x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 164, 3))
+>x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 165, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
->x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 165, 3))
+>x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 166, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
->x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 166, 3))
+>x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 167, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 167, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x163: () => Base[] = () => { return [d1, d2]; };
->x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 167, 3))
+>x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 168, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x164: () => Array<Base> = () => { return [d1, d2]; };
->x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3))
+>x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 169, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
->x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 169, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 169, 19))
+>x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 170, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 19))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
->x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 170, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 17))
+>x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 171, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 49))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 49))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; };
->x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 171, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 171, 17))
+>x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 172, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 172, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; } }; };
->x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 172, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 173, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 172, 47))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 53))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 173, 47))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 173, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x169: () => () => Base[] = function() { return () => [d1, d2]; };
->x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 173, 3))
+>x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 174, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
->x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 174, 3))
+>x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 175, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
->x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 175, 3))
+>x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 176, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 176, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
->x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 176, 3))
+>x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 177, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
->x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 177, 3))
+>x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 178, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
->x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 178, 3))
+>x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 179, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 179, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x175: () => Base[] = function() { return [d1, d2]; };
->x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 179, 3))
+>x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 180, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x176: () => Array<Base> = function() { return [d1, d2]; };
->x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3))
+>x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 181, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
->x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 181, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 181, 19))
+>x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 182, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 19))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
->x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 182, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 17))
+>x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 183, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 54))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 54))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; };
->x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 183, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 183, 17))
+>x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 184, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 184, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2]; } }; };
->x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 184, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 185, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 184, 52))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 58))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 185, 52))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 185, 58))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x181 { var t: () => Base[] = () => [d1, d2]; }
->x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 184, 90))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 185, 17))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
->x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 185, 53))
+>x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 185, 90))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
->x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 186, 69))
+module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
+>x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 186, 53))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
->x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 187, 75))
+module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
+>x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 187, 69))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 188, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
->x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 188, 56))
+module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
+>x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 188, 75))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
->x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 189, 72))
+module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
+>x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 189, 56))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x187 { var t: Base[] = [d1, d2]; }
->x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 190, 78))
+module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
+>x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 190, 72))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 191, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x187 { var t: Base[] = [d1, d2]; }
+>x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 191, 78))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x188 { var t: Array<Base> = [d1, d2]; }
->x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 191, 41))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17))
+>x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 192, 41))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x189 { var t: { [n: number]: Base; } = [d1, d2]; }
->x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 192, 46))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 193, 24))
+>x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 193, 46))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
->x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 193, 57))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 22))
+>x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 194, 57))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 22))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 39))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
->x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 194, 56))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 195, 22))
+>x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 195, 56))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 196, 22))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
->x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 195, 81))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 196, 81))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 17))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 196, 37))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 43))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 197, 37))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 197, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x193 { export var t: () => Base[] = () => [d1, d2]; }
->x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 196, 74))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 24))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
->x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 197, 60))
+>x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 197, 74))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; }
->x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 198, 76))
+module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
+>x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 198, 60))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
->x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 199, 82))
+module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; }
+>x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 199, 76))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 200, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
->x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 200, 63))
+module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
+>x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 200, 82))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; }
->x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 201, 79))
+module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
+>x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 201, 63))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-module x199 { export var t: Base[] = [d1, d2]; }
->x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 202, 85))
+module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; }
+>x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 202, 79))
 >t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 203, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+module x199 { export var t: Base[] = [d1, d2]; }
+>x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 203, 85))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x200 { export var t: Array<Base> = [d1, d2]; }
->x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 203, 48))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24))
+>x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 204, 48))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x201 { export var t: { [n: number]: Base; } = [d1, d2]; }
->x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 204, 53))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 205, 31))
+>x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 205, 53))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 31))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
->x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 205, 64))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 29))
+>x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 206, 64))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 46))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; }
->x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 206, 63))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 207, 29))
+>x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 207, 63))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 208, 29))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
->x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 207, 88))
->t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 208, 88))
+>t : Symbol(t, Decl(generatedContextualTyping.ts, 209, 24))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 208, 44))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 50))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 209, 44))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 209, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x206 = <() => Base[]>function() { return [d1, d2] };
->x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 209, 3))
+>x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 210, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x207 = <() => Base[]>function named() { return [d1, d2] };
->x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 210, 3))
+>x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 211, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 211, 25))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
->x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 211, 3))
+>x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 212, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
->x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 212, 3))
+>x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 213, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 213, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x211 = <Base[]>[d1, d2];
->x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 213, 3))
+>x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 214, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x212 = <Array<Base>>[d1, d2];
->x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 214, 3))
+>x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 215, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x213 = <{ [n: number]: Base; }>[d1, d2];
->x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 215, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 215, 15))
+>x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 216, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 15))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x214 = <{n: Base[]; } >{ n: [d1, d2] };
->x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 216, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 13))
+>x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 217, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 28))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
->x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 217, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 218, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 217, 26))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 32))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 218, 26))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 218, 32))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
->x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 218, 3))
+>x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 219, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
->x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 219, 3))
+>x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 220, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->named : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 220, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
->x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 220, 3))
+>x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 221, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
->x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 221, 3))
+>x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 222, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->named : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 222, 42))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x221 = (<Base[]>undefined) || [d1, d2];
->x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 222, 3))
+>x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 223, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x222 = (<Array<Base>>undefined) || [d1, d2];
->x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 223, 3))
+>x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 224, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
->x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 224, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 224, 16))
+>x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 225, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
->x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 225, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 14))
+>x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 226, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 43))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x225: () => Base[]; x225 = () => [d1, d2];
->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3))
+>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x226: () => Base[]; x226 = function() { return [d1, d2] };
->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3))
+>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x227: () => Base[]; x227 = function named() { return [d1, d2] };
->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3))
+>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 229, 30))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x228: { (): Base[]; }; x228 = () => [d1, d2];
->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3))
+>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3))
+>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3))
+>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 232, 33))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x231: Base[]; x231 = [d1, d2];
->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3))
+>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x232: Array<Base>; x232 = [d1, d2];
->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3))
+>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x233: { [n: number]: Base; }; x233 = [d1, d2];
->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 234, 13))
+>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 11))
+>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; };
->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 236, 11))
+>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 237, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47))
+>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 237, 32))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 38))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 238, 32))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 38))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
->x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 238, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 11))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
->x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 239, 3))
+>x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 239, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
->x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 240, 3))
+var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
+>x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 240, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
->x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 241, 3))
+var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
+>x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 241, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 37))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 34))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 241, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
->x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 242, 3))
+var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
+>x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 242, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
->x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 243, 3))
+var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
+>x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 243, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x243: { n: Base[]; } = { n: [d1, d2] };
->x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 244, 3))
+var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
+>x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 244, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 28))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 37))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 244, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x243: { n: Base[]; } = { n: [d1, d2] };
+>x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 245, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x244: { n: Array<Base>; } = { n: [d1, d2] };
->x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 245, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11))
+>x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 246, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 33))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 33))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
->x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 246, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 18))
+>x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 247, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 44))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
->x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 247, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 16))
+>x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 248, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 36))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 36))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } };
->x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 248, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 248, 16))
+>x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 249, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 249, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
->x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 249, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 250, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 11))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 34))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 249, 39))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 34))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 250, 39))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x252: { (): Base[]; }[] = [() => [d1, d2]];
->x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 250, 3))
+>x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 251, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
->x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 251, 3))
+>x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 252, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
->x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 252, 3))
+>x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 253, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 253, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x255: Base[][] = [[d1, d2]];
->x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 253, 3))
+>x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 254, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x256: Array<Base>[] = [[d1, d2]];
->x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 254, 3))
+>x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 255, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x257: { [n: number]: Base; }[] = [[d1, d2]];
->x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 255, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 255, 13))
+>x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 256, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
->x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 256, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 11))
+>x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 257, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 31))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
->x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 257, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 258, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 257, 29))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 35))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 258, 29))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 258, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x261: () => Base[] = function() { return [d1, d2] } || undefined;
->x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 258, 3))
+>x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 259, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
->x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 259, 3))
+>x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 260, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 260, 24))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
->x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 260, 3))
+>x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 261, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
->x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 261, 3))
+>x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 262, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 262, 27))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x265: Base[] = [d1, d2] || undefined;
->x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 262, 3))
+>x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 263, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x266: Array<Base> = [d1, d2] || undefined;
->x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 263, 3))
+>x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 264, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x267: { [n: number]: Base; } = [d1, d2] || undefined;
->x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 264, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 264, 13))
+>x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 265, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
->x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 265, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 11))
+>x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 266, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 28))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x269: () => Base[] = undefined || function() { return [d1, d2] };
->x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 266, 3))
+>x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 267, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x270: () => Base[] = undefined || function named() { return [d1, d2] };
->x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 267, 3))
+>x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 268, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->named : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 268, 37))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
->x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 268, 3))
+>x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 269, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
->x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 269, 3))
+>x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 270, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->named : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 270, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x273: Base[] = undefined || [d1, d2];
->x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 270, 3))
+>x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 271, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x274: Array<Base> = undefined || [d1, d2];
->x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 271, 3))
+>x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 272, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x275: { [n: number]: Base; } = undefined || [d1, d2];
->x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 272, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 272, 13))
+>x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 273, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
->x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 273, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 11))
+>x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 274, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
->x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 274, 3))
+>x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 275, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
->x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 275, 3))
+>x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 276, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 24))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 64))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
->x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 276, 3))
+>x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 277, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
->x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 277, 3))
+>x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 278, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 27))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 67))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x281: Base[] = [d1, d2] || [d1, d2];
->x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 278, 3))
+>x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 279, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x282: Array<Base> = [d1, d2] || [d1, d2];
->x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 279, 3))
+>x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 280, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2];
->x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 280, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 280, 13))
+>x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 281, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
->x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 281, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 11))
+>x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 282, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 28))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 47))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 28))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
->x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 282, 3))
+>x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 283, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
->x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 283, 3))
+>x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 284, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
->x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 284, 3))
+>x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 285, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 70))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
->x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 285, 3))
+>x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 286, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
->x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 286, 3))
+>x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 287, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
->x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 287, 3))
+>x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 288, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 73))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x291: Base[] = true ? [d1, d2] : [d1, d2];
->x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 288, 3))
+>x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 289, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
->x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 289, 3))
+>x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 290, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2];
->x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 290, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 290, 13))
+>x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 291, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
->x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 291, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 11))
+>x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 292, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 35))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 53))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 53))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; };
->x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 292, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 292, 11))
+>x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 293, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 293, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } };
->x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 293, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 294, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 33))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 39))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 71))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 77))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 33))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 71))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 77))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x297: () => Base[] = true ? undefined : () => [d1, d2];
->x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 294, 3))
+>x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 295, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
->x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 295, 3))
+>x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 296, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] };
->x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 296, 3))
+>x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 297, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->named : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 297, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
->x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 297, 3))
+>x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 298, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
->x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 298, 3))
+>x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 299, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] };
->x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 299, 3))
+>x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 300, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->named : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 300, 46))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x303: Base[] = true ? undefined : [d1, d2];
->x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 300, 3))
+>x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 301, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x304: Array<Base> = true ? undefined : [d1, d2];
->x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 301, 3))
+>x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 302, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x305: { [n: number]: Base; } = true ? undefined : [d1, d2];
->x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 302, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 302, 13))
+>x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 303, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
->x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 303, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 11))
+>x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 304, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 47))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; };
->x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 304, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 304, 11))
+>x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 305, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 305, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
->x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 305, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 306, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
->func : Symbol(func, Decl(generatedContextualTyping.ts, 305, 45))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 51))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 306, 45))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 306, 51))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x309: () => Base[] = true ? () => [d1, d2] : undefined;
->x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 306, 3))
+>x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 307, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
->x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 307, 3))
+>x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 308, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
->x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 308, 3))
+>x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 309, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 309, 31))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
->x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 309, 3))
+>x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 310, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
->x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 310, 3))
+>x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 311, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
->x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 311, 3))
+>x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 312, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 312, 34))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x315: Base[] = true ? [d1, d2] : undefined;
->x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 312, 3))
+>x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 313, 3))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x316: Array<Base> = true ? [d1, d2] : undefined;
->x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 313, 3))
+>x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 314, 3))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined;
->x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 314, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 314, 13))
+>x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 315, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 13))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
->x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 315, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 11))
+>x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 316, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 35))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 35))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined;
->x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 316, 3))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 316, 11))
+>x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 317, 3))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 317, 11))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 >undefined : Symbol(undefined)
 
 var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
->x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 317, 3))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 318, 3))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 317, 33))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 39))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 318, 33))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 39))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 >undefined : Symbol(undefined)
 
 function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 14))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57))
+>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73))
+function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
+>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79))
+function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
+>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 321, 41))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60))
+function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
+>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] });
->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76))
+function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
+>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-function x327(n: Base[]) { }; x327([d1, d2]);
->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82))
+function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] });
+>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 324, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+function x327(n: Base[]) { }; x327([d1, d2]);
+>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x328(n: Array<Base>) { }; x328([d1, d2]);
->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14))
+>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 20))
+>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 18))
+>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 44))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 44))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; });
->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 328, 18))
+>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 329, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57))
+>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 14))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 329, 42))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 48))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 330, 42))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 48))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12))
+>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12))
->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
+>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
+>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12))
->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
+>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
+>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12))
->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
+>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 333, 40))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
+>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12))
->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
+>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
+>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12))
->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
+>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] });
->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
+>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12))
->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
+>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 336, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x339 = (n: Base[]) => n; x339([d1, d2]);
->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
+>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12))
->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
+>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x340 = (n: Array<Base>) => n; x340([d1, d2]);
->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
+>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12))
->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
+>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 18))
+>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 18))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12))
->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
+>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 16))
+>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12))
->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 43))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
+>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 43))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; });
->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 340, 16))
+>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 341, 16))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12))
->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
+>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12))
->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 341, 41))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 47))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12))
+>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 342, 41))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 20))
->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
-
-var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3))
+>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3))
+var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
+>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3))
+var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] });
+>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 345, 47))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3))
+var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
+>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3))
+var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] });
+>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3))
->named : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
-var x351 = function(n: Base[]) { }; x351([d1, d2]);
->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3))
+var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] });
+>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3))
 >n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3))
+>named : Symbol(named, Decl(generatedContextualTyping.ts, 348, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
+
+var x351 = function(n: Base[]) { }; x351([d1, d2]);
+>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20))
+>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
+>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20))
+>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20))
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 26))
+>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 26))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 24))
+>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 50))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 50))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
 var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; });
->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20))
->s : Symbol(s, Decl(generatedContextualTyping.ts, 352, 24))
+>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20))
+>s : Symbol(s, Decl(generatedContextualTyping.ts, 353, 24))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63))
+>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
 
 var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; } });
->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20))
->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42))
+>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 20))
+>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42))
 >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0))
->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3))
->func : Symbol(func, Decl(generatedContextualTyping.ts, 353, 48))
->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 54))
->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19))
->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40))
+>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3))
+>func : Symbol(func, Decl(generatedContextualTyping.ts, 354, 48))
+>n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 54))
+>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19))
+>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40))
 
diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types
index e8f434d31a8..2e9625cdb8b 100644
--- a/tests/baselines/reference/generatedContextualTyping.types
+++ b/tests/baselines/reference/generatedContextualTyping.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts ===
+
 class Base { private p; }
 >Base : Base
 >p : any
diff --git a/tests/baselines/reference/getterMissingReturnError.errors.txt b/tests/baselines/reference/getterMissingReturnError.errors.txt
index 8900cc5e78f..e504de07ef4 100644
--- a/tests/baselines/reference/getterMissingReturnError.errors.txt
+++ b/tests/baselines/reference/getterMissingReturnError.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/compiler/getterMissingReturnError.ts (2 errors) ====
@@ -8,7 +8,7 @@ tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS2378: A 'get' ac
                    ~~
 !!! 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.
     
         }
     }
diff --git a/tests/baselines/reference/ifDoWhileStatements.js b/tests/baselines/reference/ifDoWhileStatements.js
index 020d3f053d1..a2553c674b0 100644
--- a/tests/baselines/reference/ifDoWhileStatements.js
+++ b/tests/baselines/reference/ifDoWhileStatements.js
@@ -1,4 +1,5 @@
 //// [ifDoWhileStatements.ts]
+
 interface I {
     id: number;
 }
diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols
index e2b375cb54b..80c8fc7f1d8 100644
--- a/tests/baselines/reference/ifDoWhileStatements.symbols
+++ b/tests/baselines/reference/ifDoWhileStatements.symbols
@@ -1,92 +1,93 @@
 === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts ===
+
 interface I {
 >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0))
 
     id: number;
->id : Symbol(id, Decl(ifDoWhileStatements.ts, 0, 13))
+>id : Symbol(id, Decl(ifDoWhileStatements.ts, 1, 13))
 }
 
 class C implements I {
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0))
 
     id: number;
->id : Symbol(id, Decl(ifDoWhileStatements.ts, 4, 22))
+>id : Symbol(id, Decl(ifDoWhileStatements.ts, 5, 22))
 
     name: string;
->name : Symbol(name, Decl(ifDoWhileStatements.ts, 5, 15))
+>name : Symbol(name, Decl(ifDoWhileStatements.ts, 6, 15))
 }
 
 class C2 extends C {
->C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 7, 1))
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 8, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
     valid: boolean;
->valid : Symbol(valid, Decl(ifDoWhileStatements.ts, 9, 20))
+>valid : Symbol(valid, Decl(ifDoWhileStatements.ts, 10, 20))
 }
 
 class D<T>{
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
 
     source: T;
->source : Symbol(source, Decl(ifDoWhileStatements.ts, 13, 11))
->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8))
+>source : Symbol(source, Decl(ifDoWhileStatements.ts, 14, 11))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
 
     recurse: D<T>;
->recurse : Symbol(recurse, Decl(ifDoWhileStatements.ts, 14, 14))
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8))
+>recurse : Symbol(recurse, Decl(ifDoWhileStatements.ts, 15, 14))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
 
     wrapped: D<D<T>>
->wrapped : Symbol(wrapped, Decl(ifDoWhileStatements.ts, 15, 18))
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8))
+>wrapped : Symbol(wrapped, Decl(ifDoWhileStatements.ts, 16, 18))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8))
 }
 
 function F(x: string): number { return 42; }
->F : Symbol(F, Decl(ifDoWhileStatements.ts, 17, 1))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 19, 11))
+>F : Symbol(F, Decl(ifDoWhileStatements.ts, 18, 1))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 11))
 
 function F2(x: number): boolean { return x < 42; }
->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 19, 44))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12))
+>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 20, 44))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12))
 
 module M {
->M : Symbol(M, Decl(ifDoWhileStatements.ts, 20, 50))
+>M : Symbol(M, Decl(ifDoWhileStatements.ts, 21, 50))
 
     export class A {
->A : Symbol(A, Decl(ifDoWhileStatements.ts, 22, 10))
+>A : Symbol(A, Decl(ifDoWhileStatements.ts, 23, 10))
 
         name: string;
->name : Symbol(name, Decl(ifDoWhileStatements.ts, 23, 20))
+>name : Symbol(name, Decl(ifDoWhileStatements.ts, 24, 20))
     }
 
     export function F2(x: number): string { return x.toString(); }
->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 25, 5))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23))
+>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 26, 5))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23))
 >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 module N {
->N : Symbol(N, Decl(ifDoWhileStatements.ts, 28, 1))
+>N : Symbol(N, Decl(ifDoWhileStatements.ts, 29, 1))
 
     export class A {
->A : Symbol(A, Decl(ifDoWhileStatements.ts, 30, 10))
+>A : Symbol(A, Decl(ifDoWhileStatements.ts, 31, 10))
 
         id: number;
->id : Symbol(id, Decl(ifDoWhileStatements.ts, 31, 20))
+>id : Symbol(id, Decl(ifDoWhileStatements.ts, 32, 20))
     }
 
     export function F2(x: number): string { return x.toString(); }
->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 33, 5))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23))
+>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 34, 5))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23))
 >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
@@ -137,200 +138,200 @@ while ({}) { }
 do { }while({})
 
 if ({ x: 1, y: 'a' }) { }
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 79, 5))
->y : Symbol(y, Decl(ifDoWhileStatements.ts, 79, 11))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 5))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 11))
 
 while ({ x: 1, y: 'a' }) { }
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 8))
->y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 14))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 8))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 14))
 
 do { }while({ x: 1, y: 'a' })
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 13))
->y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 19))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 82, 13))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 82, 19))
 
 if (() => 43) { }
 while (() => 43) { }
 do { }while(() => 43)
 
 if (new C()) { }
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
 while (new C()) { }
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
 do { }while(new C())
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
 if (new D<C>()) { }
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
 while (new D<C>()) { }
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
 do { }while(new D<C>())
->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1))
->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1))
+>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1))
+>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1))
 
 // references
 var a = true;
->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3))
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
 
 if (a) { }
->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3))
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
 
 while (a) { }
->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3))
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
 
 do { }while(a)
->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3))
+>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3))
 
 var b = null;
->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3))
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
 
 if (b) { }
->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3))
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
 
 while (b) { }
->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3))
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
 
 do { }while(b)
->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3))
+>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3))
 
 var c = undefined;
->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3))
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
 >undefined : Symbol(undefined)
 
 if (c) { }
->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3))
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
 
 while (c) { }
->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3))
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
 
 do { }while(c)
->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3))
+>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3))
 
 var d = 0.0;
->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3))
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
 
 if (d) { }
->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3))
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
 
 while (d) { }
->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3))
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
 
 do { }while(d)
->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3))
+>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3))
 
 var e = 'a string';
->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3))
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
 
 if (e) { }
->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3))
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
 
 while (e) { }
->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3))
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
 
 do { }while(e)
->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3))
+>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3))
 
 var f = '';
->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3))
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
 
 if (f) { }
->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3))
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
 
 while (f) { }
->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3))
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
 
 do { }while(f)
->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3))
+>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3))
 
 var g = /[a-z]/
->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3))
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
 
 if (g) { }
->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3))
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
 
 while (g) { }
->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3))
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
 
 do { }while(g)
->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3))
+>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3))
 
 var h = [];
->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3))
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
 
 if (h) { }
->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3))
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
 
 while (h) { }
->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3))
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
 
 do { }while(h)
->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3))
+>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3))
 
 var i = [1, 2];
->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3))
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
 
 if (i) { }
->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3))
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
 
 while (i) { }
->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3))
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
 
 do { }while(i)
->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3))
+>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3))
 
 var j = {};
->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
 
 if (j) { }
->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
 
 while (j) { }
->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
 
 do { }while(j)
->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3))
+>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3))
 
 var k = { x: 1, y: 'a' };
->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 146, 9))
->y : Symbol(y, Decl(ifDoWhileStatements.ts, 146, 15))
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 147, 9))
+>y : Symbol(y, Decl(ifDoWhileStatements.ts, 147, 15))
 
 if (k) { }
->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3))
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
 
 while (k) { }
->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3))
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
 
 do { }while(k)
->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3))
+>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3))
 
 function fn(x?: string): I { return null; }
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
->x : Symbol(x, Decl(ifDoWhileStatements.ts, 151, 12))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
+>x : Symbol(x, Decl(ifDoWhileStatements.ts, 152, 12))
 >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0))
 
 if (fn()) { }
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
 
 while (fn()) { }
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
 
 do { }while(fn())
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
 
 if (fn) { }
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
 
 while (fn) { }
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
 
 do { }while(fn)
->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14))
+>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14))
 
 
 
diff --git a/tests/baselines/reference/ifDoWhileStatements.types b/tests/baselines/reference/ifDoWhileStatements.types
index 92a9df6a4dd..660eaa4fb63 100644
--- a/tests/baselines/reference/ifDoWhileStatements.types
+++ b/tests/baselines/reference/ifDoWhileStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts ===
+
 interface I {
 >I : I
 
diff --git a/tests/baselines/reference/ifElseWithStatements1.errors.txt b/tests/baselines/reference/ifElseWithStatements1.errors.txt
index 186cff59241..5dc4d9b0db5 100644
--- a/tests/baselines/reference/ifElseWithStatements1.errors.txt
+++ b/tests/baselines/reference/ifElseWithStatements1.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/compiler/ifElseWithStatements1.ts(2,5): error TS2304: Cannot find name 'f'.
-tests/cases/compiler/ifElseWithStatements1.ts(4,5): error TS2304: Cannot find name 'f'.
+tests/cases/compiler/ifElseWithStatements1.ts(3,5): error TS2304: Cannot find name 'f'.
+tests/cases/compiler/ifElseWithStatements1.ts(5,5): error TS2304: Cannot find name 'f'.
 
 
 ==== tests/cases/compiler/ifElseWithStatements1.ts (2 errors) ====
+    
     if (true)
         f();
         ~
diff --git a/tests/baselines/reference/ifElseWithStatements1.js b/tests/baselines/reference/ifElseWithStatements1.js
index 506e7e6a330..47df08d46ba 100644
--- a/tests/baselines/reference/ifElseWithStatements1.js
+++ b/tests/baselines/reference/ifElseWithStatements1.js
@@ -1,4 +1,5 @@
 //// [ifElseWithStatements1.ts]
+
 if (true)
     f();
 else
diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt
index 99819ecad2c..bab58d0e4cf 100644
--- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt
+++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(1,10): error TS2354: No best common type exists among return expressions.
+tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(2,10): error TS2354: No best common type exists among return expressions.
 
 
 ==== tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts (1 errors) ====
+    
     function foo() {
              ~~~
 !!! error TS2354: No best common type exists among return expressions.
diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js
index ba528d4c133..2993a331fee 100644
--- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js
+++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js
@@ -1,4 +1,5 @@
 //// [inferredFunctionReturnTypeIsEmptyType.ts]
+
 function foo() {
     if (true) {
         return 42;
diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt
index 08aab5b1158..787b95f2297 100644
--- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt
+++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(5,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
+tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(6,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 
 
 ==== tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts (2 errors) ====
+    
     class a {
         static get x(): () => string {
                    ~
diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js
index b81b6cd1d78..fa9c6e2a8b5 100644
--- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js
+++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js
@@ -1,4 +1,5 @@
 //// [inheritanceStaticPropertyOverridingAccessor.ts]
+
 class a {
     static get x(): () => string {
         return null;;
diff --git a/tests/baselines/reference/interfaceExtendingClass2.errors.txt b/tests/baselines/reference/interfaceExtendingClass2.errors.txt
index 3b394d4922a..859cb65410e 100644
--- a/tests/baselines/reference/interfaceExtendingClass2.errors.txt
+++ b/tests/baselines/reference/interfaceExtendingClass2.errors.txt
@@ -1,10 +1,11 @@
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(11,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(13,13): error TS1131: Property or signature expected.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,9): error TS1128: Declaration or statement expected.
-tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,5): error TS1128: Declaration or statement expected.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(12,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,13): error TS1131: Property or signature expected.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,9): error TS1128: Declaration or statement expected.
+tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(16,5): error TS1128: Declaration or statement expected.
 
 
 ==== tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts (4 errors) ====
+    
     class Foo {
         x: string;
         y() { }
diff --git a/tests/baselines/reference/interfaceExtendingClass2.js b/tests/baselines/reference/interfaceExtendingClass2.js
index 6e6605e2459..c4143659125 100644
--- a/tests/baselines/reference/interfaceExtendingClass2.js
+++ b/tests/baselines/reference/interfaceExtendingClass2.js
@@ -1,4 +1,5 @@
 //// [interfaceExtendingClass2.ts]
+
 class Foo {
     x: string;
     y() { }
diff --git a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt
index 7f2542b45a1..dc1cfeabed5 100644
--- a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt
+++ b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt
@@ -1,11 +1,12 @@
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(4,5): error TS1131: Property or signature expected.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(8,5): error TS1131: Property or signature expected.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,5): error TS1131: Property or signature expected.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,16): error TS2304: Cannot find name 'string'.
-tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(5,5): error TS1131: Property or signature expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(9,5): error TS1131: Property or signature expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,5): error TS1131: Property or signature expected.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,16): error TS2304: Cannot find name 'string'.
+tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(14,1): error TS1128: Declaration or statement expected.
 
 
 ==== tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts (5 errors) ====
+    
     // interfaces do not permit private members, these are errors
     
     interface I {
diff --git a/tests/baselines/reference/interfaceWithPrivateMember.js b/tests/baselines/reference/interfaceWithPrivateMember.js
index 24c2cf9ecf5..ceb388b1eae 100644
--- a/tests/baselines/reference/interfaceWithPrivateMember.js
+++ b/tests/baselines/reference/interfaceWithPrivateMember.js
@@ -1,4 +1,5 @@
 //// [interfaceWithPrivateMember.ts]
+
 // interfaces do not permit private members, these are errors
 
 interface I {
diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt
index 65fd55b763b..15983bd1fc4 100644
--- a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(8,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(9,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
 ==== tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked break not allowed
diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.js b/tests/baselines/reference/invalidDoWhileBreakStatements.js
index 807d58a8fea..4f48a890aa6 100644
--- a/tests/baselines/reference/invalidDoWhileBreakStatements.js
+++ b/tests/baselines/reference/invalidDoWhileBreakStatements.js
@@ -1,4 +1,5 @@
 //// [invalidDoWhileBreakStatements.ts]
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt
index e9643394d12..3a520209293 100644
--- a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(8,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(9,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
 ==== tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.js b/tests/baselines/reference/invalidDoWhileContinueStatements.js
index 21a10a3451b..b77259159a9 100644
--- a/tests/baselines/reference/invalidDoWhileContinueStatements.js
+++ b/tests/baselines/reference/invalidDoWhileContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidDoWhileContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/invalidForBreakStatements.errors.txt b/tests/baselines/reference/invalidForBreakStatements.errors.txt
index 50e4013c0ea..57ae1d32c8e 100644
--- a/tests/baselines/reference/invalidForBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidForBreakStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(8,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(36,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(9,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
 ==== tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked break not allowed
diff --git a/tests/baselines/reference/invalidForBreakStatements.js b/tests/baselines/reference/invalidForBreakStatements.js
index 5e3430ecb41..50096e16720 100644
--- a/tests/baselines/reference/invalidForBreakStatements.js
+++ b/tests/baselines/reference/invalidForBreakStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForBreakStatements.ts]
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/baselines/reference/invalidForContinueStatements.errors.txt b/tests/baselines/reference/invalidForContinueStatements.errors.txt
index 3af47370df1..9ebfae57e9f 100644
--- a/tests/baselines/reference/invalidForContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidForContinueStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(8,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(36,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(9,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
 ==== tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
diff --git a/tests/baselines/reference/invalidForContinueStatements.js b/tests/baselines/reference/invalidForContinueStatements.js
index 2db1ce69ede..7a3513bb2a3 100644
--- a/tests/baselines/reference/invalidForContinueStatements.js
+++ b/tests/baselines/reference/invalidForContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/invalidForInBreakStatements.errors.txt b/tests/baselines/reference/invalidForInBreakStatements.errors.txt
index d83304ab1c6..b1f5d64f973 100644
--- a/tests/baselines/reference/invalidForInBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidForInBreakStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(8,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
-tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(9,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
 ==== tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked break not allowed
diff --git a/tests/baselines/reference/invalidForInBreakStatements.js b/tests/baselines/reference/invalidForInBreakStatements.js
index 1784b9a57a6..11517f2a020 100644
--- a/tests/baselines/reference/invalidForInBreakStatements.js
+++ b/tests/baselines/reference/invalidForInBreakStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForInBreakStatements.ts]
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/baselines/reference/invalidForInContinueStatements.errors.txt b/tests/baselines/reference/invalidForInContinueStatements.errors.txt
index 7353a22d9cd..f20d9c6e81c 100644
--- a/tests/baselines/reference/invalidForInContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidForInContinueStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(8,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(9,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
 ==== tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
diff --git a/tests/baselines/reference/invalidForInContinueStatements.js b/tests/baselines/reference/invalidForInContinueStatements.js
index 94020d00f2b..5eb0e10bf53 100644
--- a/tests/baselines/reference/invalidForInContinueStatements.js
+++ b/tests/baselines/reference/invalidForInContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidForInContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/invalidReturnStatements.errors.txt b/tests/baselines/reference/invalidReturnStatements.errors.txt
index 780166e07c2..6fbe961cd54 100644
--- a/tests/baselines/reference/invalidReturnStatements.errors.txt
+++ b/tests/baselines/reference/invalidReturnStatements.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/statements/returnStatements/invalidReturnStatements.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/conformance/statements/returnStatements/invalidReturnStatements.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/conformance/statements/returnStatements/invalidReturnStatements.ts(4,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/conformance/statements/returnStatements/invalidReturnStatements.ts(5,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/conformance/statements/returnStatements/invalidReturnStatements.ts(2,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(3,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(4,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(5,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(16,29): error TS2322: Type '{ id: number; }' is not assignable to type 'D'.
   Property 'name' is missing in type '{ id: number; }'.
 tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(18,29): error TS2322: Type 'C' is not assignable to type 'D'.
@@ -12,16 +12,16 @@ tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(1
     // all the following should be error
     function fn1(): number {  }
                     ~~~~~~
-!!! 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 fn2(): string { }
                     ~~~~~~
-!!! 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 fn3(): boolean { }
                     ~~~~~~~
-!!! 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 fn4(): Date {  }
                     ~~~~
-!!! 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 fn7(): any {  } // should be valid: any includes void
     
     interface I { id: number }
diff --git a/tests/baselines/reference/invalidThrowStatement.errors.txt b/tests/baselines/reference/invalidThrowStatement.errors.txt
index b30549a217c..3002bce2f1f 100644
--- a/tests/baselines/reference/invalidThrowStatement.errors.txt
+++ b/tests/baselines/reference/invalidThrowStatement.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(1,6): error TS1109: Expression expected.
-tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(2,6): error TS1109: Expression expected.
+tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(4,1): error TS1128: Declaration or statement expected.
 
 
 ==== tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts (2 errors) ====
+    
     throw; 
          ~
 !!! error TS1109: Expression expected.
diff --git a/tests/baselines/reference/invalidThrowStatement.js b/tests/baselines/reference/invalidThrowStatement.js
index 4b794ab3d51..674dacf5c17 100644
--- a/tests/baselines/reference/invalidThrowStatement.js
+++ b/tests/baselines/reference/invalidThrowStatement.js
@@ -1,4 +1,5 @@
 //// [invalidThrowStatement.ts]
+
 throw; 
 
 export throw null;
diff --git a/tests/baselines/reference/invalidWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidWhileBreakStatements.errors.txt
index 54adc2856d7..7d4f86b3e9d 100644
--- a/tests/baselines/reference/invalidWhileBreakStatements.errors.txt
+++ b/tests/baselines/reference/invalidWhileBreakStatements.errors.txt
@@ -1,12 +1,14 @@
 tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement.
+tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(7,1): error TS7028: Unused label.
 tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(8,14): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
+tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(11,1): error TS7027: Unreachable code detected.
 tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
 tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
 tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
 
 
-==== tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts (6 errors) ====
+==== tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts (8 errors) ====
     // All errors
     
     // naked break not allowed
@@ -16,12 +18,16 @@ tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.t
     
     // non-existent label
     ONE:
+    ~~~
+!!! error TS7028: Unused label.
     while (true) break TWO;
                  ~~~~~~~~~~
 !!! error TS1116: A 'break' statement can only jump to a label of an enclosing statement.
     
     // break from inside function
     TWO:
+    ~~~
+!!! error TS7027: Unreachable code detected.
     while (true){
         var x = () => {
             break TWO;
diff --git a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt
index 462b244efd4..e7a9ed13c40 100644
--- a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt
+++ b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt
@@ -1,12 +1,13 @@
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(8,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
-tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(9,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
+tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement.
 
 
 ==== tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts (6 errors) ====
+    
     // All errors
     
     // naked continue not allowed
diff --git a/tests/baselines/reference/invalidWhileContinueStatements.js b/tests/baselines/reference/invalidWhileContinueStatements.js
index b8234bf9604..16350e9b561 100644
--- a/tests/baselines/reference/invalidWhileContinueStatements.js
+++ b/tests/baselines/reference/invalidWhileContinueStatements.js
@@ -1,4 +1,5 @@
 //// [invalidWhileContinueStatements.ts]
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/baselines/reference/letAndVarRedeclaration.errors.txt b/tests/baselines/reference/letAndVarRedeclaration.errors.txt
index 48704f61040..50a916e8d90 100644
--- a/tests/baselines/reference/letAndVarRedeclaration.errors.txt
+++ b/tests/baselines/reference/letAndVarRedeclaration.errors.txt
@@ -1,28 +1,29 @@
-tests/cases/compiler/letAndVarRedeclaration.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'e0'.
 tests/cases/compiler/letAndVarRedeclaration.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'e0'.
-tests/cases/compiler/letAndVarRedeclaration.ts(4,10): error TS2451: Cannot redeclare block-scoped variable 'e0'.
-tests/cases/compiler/letAndVarRedeclaration.ts(7,9): error TS2451: Cannot redeclare block-scoped variable 'x1'.
+tests/cases/compiler/letAndVarRedeclaration.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'e0'.
+tests/cases/compiler/letAndVarRedeclaration.ts(5,10): error TS2451: Cannot redeclare block-scoped variable 'e0'.
 tests/cases/compiler/letAndVarRedeclaration.ts(8,9): error TS2451: Cannot redeclare block-scoped variable 'x1'.
-tests/cases/compiler/letAndVarRedeclaration.ts(9,14): error TS2451: Cannot redeclare block-scoped variable 'x1'.
-tests/cases/compiler/letAndVarRedeclaration.ts(13,9): error TS2451: Cannot redeclare block-scoped variable 'x'.
-tests/cases/compiler/letAndVarRedeclaration.ts(15,13): error TS2451: Cannot redeclare block-scoped variable 'x'.
-tests/cases/compiler/letAndVarRedeclaration.ts(18,18): error TS2451: Cannot redeclare block-scoped variable 'x'.
-tests/cases/compiler/letAndVarRedeclaration.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(9,9): error TS2451: Cannot redeclare block-scoped variable 'x1'.
+tests/cases/compiler/letAndVarRedeclaration.ts(10,14): error TS2451: Cannot redeclare block-scoped variable 'x1'.
+tests/cases/compiler/letAndVarRedeclaration.ts(14,9): error TS2451: Cannot redeclare block-scoped variable 'x'.
+tests/cases/compiler/letAndVarRedeclaration.ts(16,13): error TS2451: Cannot redeclare block-scoped variable 'x'.
+tests/cases/compiler/letAndVarRedeclaration.ts(19,18): error TS2451: Cannot redeclare block-scoped variable 'x'.
 tests/cases/compiler/letAndVarRedeclaration.ts(24,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(25,14): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(29,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(31,13): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(34,18): error TS2451: Cannot redeclare block-scoped variable 'x2'.
-tests/cases/compiler/letAndVarRedeclaration.ts(38,5): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(39,10): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(43,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(44,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(49,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
-tests/cases/compiler/letAndVarRedeclaration.ts(50,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(25,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(26,14): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(30,9): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(35,18): error TS2451: Cannot redeclare block-scoped variable 'x2'.
+tests/cases/compiler/letAndVarRedeclaration.ts(39,5): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(40,10): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(44,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(45,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(50,9): error TS2451: Cannot redeclare block-scoped variable 'x11'.
+tests/cases/compiler/letAndVarRedeclaration.ts(51,14): error TS2451: Cannot redeclare block-scoped variable 'x11'.
 
 
 ==== tests/cases/compiler/letAndVarRedeclaration.ts (21 errors) ====
     
+    
     let e0
         ~~
 !!! error TS2451: Cannot redeclare block-scoped variable 'e0'.
diff --git a/tests/baselines/reference/letAndVarRedeclaration.js b/tests/baselines/reference/letAndVarRedeclaration.js
index fd4bfe67cac..eb4dfc9c0e8 100644
--- a/tests/baselines/reference/letAndVarRedeclaration.js
+++ b/tests/baselines/reference/letAndVarRedeclaration.js
@@ -1,5 +1,6 @@
 //// [letAndVarRedeclaration.ts]
 
+
 let e0
 var e0;
 function e0() { }
diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
index 1ece1f31433..e46554ec0e6 100644
--- a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
+++ b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt
@@ -1,16 +1,17 @@
-tests/cases/compiler/letDeclarations-invalidContexts.ts(4,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(6,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(9,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(12,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(16,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(20,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(23,5): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(26,12): error TS1157: 'let' declarations can only be declared inside a block.
-tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(5,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(7,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(10,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(13,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(17,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(21,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(24,5): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(27,12): error TS1157: 'let' declarations can only be declared inside a block.
+tests/cases/compiler/letDeclarations-invalidContexts.ts(30,29): error TS1157: 'let' declarations can only be declared inside a block.
 
 
 ==== tests/cases/compiler/letDeclarations-invalidContexts.ts (9 errors) ====
     
+    
     // Errors, let must be defined inside a block
     if (true) 
         let l1 = 0;
diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.js b/tests/baselines/reference/letDeclarations-invalidContexts.js
index f8c3bb04bdb..4c3be1faed8 100644
--- a/tests/baselines/reference/letDeclarations-invalidContexts.js
+++ b/tests/baselines/reference/letDeclarations-invalidContexts.js
@@ -1,5 +1,6 @@
 //// [letDeclarations-invalidContexts.ts]
 
+
 // Errors, let must be defined inside a block
 if (true) 
     let l1 = 0;
diff --git a/tests/baselines/reference/letDeclarations-scopes.errors.txt b/tests/baselines/reference/letDeclarations-scopes.errors.txt
index 5c89ea98049..1b10903af7c 100644
--- a/tests/baselines/reference/letDeclarations-scopes.errors.txt
+++ b/tests/baselines/reference/letDeclarations-scopes.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/compiler/letDeclarations-scopes.ts(28,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
+tests/cases/compiler/letDeclarations-scopes.ts(29,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
 ==== tests/cases/compiler/letDeclarations-scopes.ts (1 errors) ====
     
+    
     // global
     let l = "string";
     
diff --git a/tests/baselines/reference/letDeclarations-scopes.js b/tests/baselines/reference/letDeclarations-scopes.js
index d0489820d0b..3fc5976b4b7 100644
--- a/tests/baselines/reference/letDeclarations-scopes.js
+++ b/tests/baselines/reference/letDeclarations-scopes.js
@@ -1,5 +1,6 @@
 //// [letDeclarations-scopes.ts]
 
+
 // global
 let l = "string";
 
diff --git a/tests/baselines/reference/letDeclarations-validContexts.errors.txt b/tests/baselines/reference/letDeclarations-validContexts.errors.txt
index 3f3b7a2634f..acec026daf0 100644
--- a/tests/baselines/reference/letDeclarations-validContexts.errors.txt
+++ b/tests/baselines/reference/letDeclarations-validContexts.errors.txt
@@ -1,9 +1,10 @@
-tests/cases/compiler/letDeclarations-validContexts.ts(20,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
+tests/cases/compiler/letDeclarations-validContexts.ts(21,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
 ==== tests/cases/compiler/letDeclarations-validContexts.ts (1 errors) ====
     
     
+    
     // Control flow statements with blocks
     if (true) { 
         let l1 = 0;
diff --git a/tests/baselines/reference/letDeclarations-validContexts.js b/tests/baselines/reference/letDeclarations-validContexts.js
index b11a1922383..1859a0215bb 100644
--- a/tests/baselines/reference/letDeclarations-validContexts.js
+++ b/tests/baselines/reference/letDeclarations-validContexts.js
@@ -1,6 +1,7 @@
 //// [letDeclarations-validContexts.ts]
 
 
+
 // Control flow statements with blocks
 if (true) { 
     let l1 = 0;
diff --git a/tests/baselines/reference/localTypes4.errors.txt b/tests/baselines/reference/localTypes4.errors.txt
index cad9d30c933..4d08644ea89 100644
--- a/tests/baselines/reference/localTypes4.errors.txt
+++ b/tests/baselines/reference/localTypes4.errors.txt
@@ -1,10 +1,11 @@
-tests/cases/conformance/types/localTypes/localTypes4.ts(10,19): error TS2304: Cannot find name 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(10,23): error TS2304: Cannot find name 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(18,16): error TS2300: Duplicate identifier 'T'.
-tests/cases/conformance/types/localTypes/localTypes4.ts(19,19): error TS2300: Duplicate identifier 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(11,19): error TS2304: Cannot find name 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(11,23): error TS2304: Cannot find name 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(19,16): error TS2300: Duplicate identifier 'T'.
+tests/cases/conformance/types/localTypes/localTypes4.ts(20,19): error TS2300: Duplicate identifier 'T'.
 
 
 ==== tests/cases/conformance/types/localTypes/localTypes4.ts (4 errors) ====
+    
     function f1() {
         // Type parameters are in scope in parameters and return types
         function f<T>(x: T): T {
diff --git a/tests/baselines/reference/localTypes4.js b/tests/baselines/reference/localTypes4.js
index 8f51761a65a..3b81175d2b6 100644
--- a/tests/baselines/reference/localTypes4.js
+++ b/tests/baselines/reference/localTypes4.js
@@ -1,4 +1,5 @@
 //// [localTypes4.ts]
+
 function f1() {
     // Type parameters are in scope in parameters and return types
     function f<T>(x: T): T {
diff --git a/tests/baselines/reference/methodInAmbientClass1.errors.txt b/tests/baselines/reference/methodInAmbientClass1.errors.txt
index 2badd839270..c931cc0101c 100644
--- a/tests/baselines/reference/methodInAmbientClass1.errors.txt
+++ b/tests/baselines/reference/methodInAmbientClass1.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/methodInAmbientClass1.ts(2,12): 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/methodInAmbientClass1.ts(2,12): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1183: An implementation cannot be declared in ambient contexts.
 
 
@@ -6,7 +6,7 @@ tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1183: An implementa
         declare class Foo {
         	fn(): boolean {
         	      ~~~~~~~
-!!! 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 TS1183: An implementation cannot be declared in ambient contexts.
         	}
diff --git a/tests/baselines/reference/missingReturnStatement.errors.txt b/tests/baselines/reference/missingReturnStatement.errors.txt
index c7cedd793de..8926d22be3d 100644
--- a/tests/baselines/reference/missingReturnStatement.errors.txt
+++ b/tests/baselines/reference/missingReturnStatement.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/missingReturnStatement.ts(3,22): 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/missingReturnStatement.ts(3,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 
 
 ==== tests/cases/compiler/missingReturnStatement.ts (1 errors) ====
@@ -6,7 +6,7 @@ tests/cases/compiler/missingReturnStatement.ts(3,22): error TS2355: A function w
         export class Bug {
             public foo():string {
                          ~~~~~~
-!!! 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.
             }
         }    
     }
diff --git a/tests/baselines/reference/missingReturnStatement1.errors.txt b/tests/baselines/reference/missingReturnStatement1.errors.txt
index de471f90ac4..9d3cf78411e 100644
--- a/tests/baselines/reference/missingReturnStatement1.errors.txt
+++ b/tests/baselines/reference/missingReturnStatement1.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/compiler/missingReturnStatement1.ts(2,12): 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/missingReturnStatement1.ts(2,12): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 
 
 ==== tests/cases/compiler/missingReturnStatement1.ts (1 errors) ====
     class Foo {
         foo(): number {
                ~~~~~~
-!!! 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.
             //return 4;
         }
     }
diff --git a/tests/baselines/reference/multiLineErrors.errors.txt b/tests/baselines/reference/multiLineErrors.errors.txt
index 23a6278b4fb..70366aeabed 100644
--- a/tests/baselines/reference/multiLineErrors.errors.txt
+++ b/tests/baselines/reference/multiLineErrors.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/multiLineErrors.ts(3,22): 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/multiLineErrors.ts(3,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/multiLineErrors.ts(21,1): error TS2322: Type 'A2' is not assignable to type 'A1'.
   Types of property 'x' are incompatible.
     Type '{ y: string; }' is not assignable to type '{ y: number; }'.
@@ -17,7 +17,7 @@ tests/cases/compiler/multiLineErrors.ts(21,1): error TS2322: Type 'A2' is not as
     ~~~~~~~~~~~~~~
     }
     ~
-!!! 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.
     {
         var x = 4;
         var y = 10;
diff --git a/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.js b/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.js
new file mode 100644
index 00000000000..b2f08b599be
--- /dev/null
+++ b/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.js
@@ -0,0 +1,10 @@
+//// [noReachabilityErrorsOnEmptyStatement.ts]
+function foo() {
+    return 1;;
+}
+
+//// [noReachabilityErrorsOnEmptyStatement.js]
+function foo() {
+    return 1;
+    ;
+}
diff --git a/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.symbols b/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.symbols
new file mode 100644
index 00000000000..0179e5150bb
--- /dev/null
+++ b/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/noReachabilityErrorsOnEmptyStatement.ts ===
+function foo() {
+>foo : Symbol(foo, Decl(noReachabilityErrorsOnEmptyStatement.ts, 0, 0))
+
+    return 1;;
+}
diff --git a/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.types b/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.types
new file mode 100644
index 00000000000..e90fa04699b
--- /dev/null
+++ b/tests/baselines/reference/noReachabilityErrorsOnEmptyStatement.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/noReachabilityErrorsOnEmptyStatement.ts ===
+function foo() {
+>foo : () => number
+
+    return 1;;
+>1 : number
+}
diff --git a/tests/baselines/reference/null.js b/tests/baselines/reference/null.js
index 499d6901847..ee897643fb1 100644
--- a/tests/baselines/reference/null.js
+++ b/tests/baselines/reference/null.js
@@ -1,4 +1,5 @@
 //// [null.ts]
+
 var x=null; 
 var y=3+x;  
 var z=3+null; 
diff --git a/tests/baselines/reference/null.symbols b/tests/baselines/reference/null.symbols
index 148cd1586b2..bd3d835995b 100644
--- a/tests/baselines/reference/null.symbols
+++ b/tests/baselines/reference/null.symbols
@@ -1,44 +1,45 @@
 === tests/cases/compiler/null.ts ===
+
 var x=null; 
->x : Symbol(x, Decl(null.ts, 0, 3))
+>x : Symbol(x, Decl(null.ts, 1, 3))
 
 var y=3+x;  
->y : Symbol(y, Decl(null.ts, 1, 3))
->x : Symbol(x, Decl(null.ts, 0, 3))
+>y : Symbol(y, Decl(null.ts, 2, 3))
+>x : Symbol(x, Decl(null.ts, 1, 3))
 
 var z=3+null; 
->z : Symbol(z, Decl(null.ts, 2, 3))
+>z : Symbol(z, Decl(null.ts, 3, 3))
 
 class C {
->C : Symbol(C, Decl(null.ts, 2, 13))
+>C : Symbol(C, Decl(null.ts, 3, 13))
 }
 function f() {
->f : Symbol(f, Decl(null.ts, 4, 1))
+>f : Symbol(f, Decl(null.ts, 5, 1))
 
     return null;
     return new C();
->C : Symbol(C, Decl(null.ts, 2, 13))
+>C : Symbol(C, Decl(null.ts, 3, 13))
 }
 function g() {
->g : Symbol(g, Decl(null.ts, 8, 1))
+>g : Symbol(g, Decl(null.ts, 9, 1))
 
     return null;
     return 3;
 }
 interface I {
->I : Symbol(I, Decl(null.ts, 12, 1))
+>I : Symbol(I, Decl(null.ts, 13, 1))
 
     x:any;
->x : Symbol(x, Decl(null.ts, 13, 13))
+>x : Symbol(x, Decl(null.ts, 14, 13))
 
     y:number;
->y : Symbol(y, Decl(null.ts, 14, 10))
+>y : Symbol(y, Decl(null.ts, 15, 10))
 }
 var w:I={x:null,y:3};
->w : Symbol(w, Decl(null.ts, 17, 3))
->I : Symbol(I, Decl(null.ts, 12, 1))
->x : Symbol(x, Decl(null.ts, 17, 9))
->y : Symbol(y, Decl(null.ts, 17, 16))
+>w : Symbol(w, Decl(null.ts, 18, 3))
+>I : Symbol(I, Decl(null.ts, 13, 1))
+>x : Symbol(x, Decl(null.ts, 18, 9))
+>y : Symbol(y, Decl(null.ts, 18, 16))
 
 
 
diff --git a/tests/baselines/reference/null.types b/tests/baselines/reference/null.types
index 7df551b1bde..6fd8b423f13 100644
--- a/tests/baselines/reference/null.types
+++ b/tests/baselines/reference/null.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/null.ts ===
+
 var x=null; 
 >x : any
 >null : null
diff --git a/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt b/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt
index e939725ea6e..be2bea5e241 100644
--- a/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt
+++ b/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/compiler/objectLiteralMemberWithModifiers2.ts (2 errors) ====
@@ -7,4 +7,4 @@ tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS2378: A
                          ~~~
 !!! 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.
\ No newline at end of file
+!!! error TS2378: A 'get' accessor must return a value.
\ No newline at end of file
diff --git a/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt b/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt
index 7373c3d535d..5a24f29252c 100644
--- a/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt
+++ b/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt
@@ -1,7 +1,7 @@
 tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,20): error TS1005: ',' expected.
 tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,25): error TS2304: Cannot find name 'b'.
 tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,26): error TS1005: ',' expected.
-tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,32): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,32): error TS2378: A 'get' accessor must return a value.
 tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,41): error TS1005: ',' expected.
 
 
@@ -14,6 +14,6 @@ tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,41): error TS1005: ',' ex
                              ~
 !!! error TS1005: ',' expected.
                                    ~~~
-!!! 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 TS1005: ',' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt
index 079951880ab..a78e0c8abcf 100644
--- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt
+++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,8): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
-tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,37): error TS1005: ';' expected.
+tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(2,8): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
+tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(2,37): error TS1005: ';' expected.
 
 
 ==== tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts (2 errors) ====
+    
     var f: (x: 'hi') => number = ('hi') => { return 1; };
            ~~~~~~~~~~~~~~~~~~~
 !!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js
index 48e52ba0967..aa5c8701f28 100644
--- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js
+++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js
@@ -1,4 +1,5 @@
 //// [overloadOnConstAsTypeAnnotation.ts]
+
 var f: (x: 'hi') => number = ('hi') => { return 1; };
 
 //// [overloadOnConstAsTypeAnnotation.js]
diff --git a/tests/baselines/reference/parser10.1.1-8gs.errors.txt b/tests/baselines/reference/parser10.1.1-8gs.errors.txt
index 185665d23da..3426ccab8da 100644
--- a/tests/baselines/reference/parser10.1.1-8gs.errors.txt
+++ b/tests/baselines/reference/parser10.1.1-8gs.errors.txt
@@ -1,8 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'.
-tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode
+tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,7): error TS2304: Cannot find name 'NotEarlyError'.
+tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(18,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode
 
 
 ==== tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts (2 errors) ====
+    
     /// Copyright (c) 2012 Ecma International.  All rights reserved. 
     /// Ecma International makes this code available under the terms and conditions set
     /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
diff --git a/tests/baselines/reference/parser10.1.1-8gs.js b/tests/baselines/reference/parser10.1.1-8gs.js
index e7d342cf1f1..fb3b96f6baf 100644
--- a/tests/baselines/reference/parser10.1.1-8gs.js
+++ b/tests/baselines/reference/parser10.1.1-8gs.js
@@ -1,4 +1,5 @@
 //// [parser10.1.1-8gs.ts]
+
 /// Copyright (c) 2012 Ecma International.  All rights reserved. 
 /// Ecma International makes this code available under the terms and conditions set
 /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
diff --git a/tests/baselines/reference/parser768531.js b/tests/baselines/reference/parser768531.js
index 26e22117717..462db3742b3 100644
--- a/tests/baselines/reference/parser768531.js
+++ b/tests/baselines/reference/parser768531.js
@@ -1,4 +1,5 @@
 //// [parser768531.ts]
+
 {a: 3}
 /x/
 
diff --git a/tests/baselines/reference/parser768531.symbols b/tests/baselines/reference/parser768531.symbols
index 2da2298c8e2..f180922c7e0 100644
--- a/tests/baselines/reference/parser768531.symbols
+++ b/tests/baselines/reference/parser768531.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts ===
-{a: 3}
+
+No type information for this code.{a: 3}
 No type information for this code./x/
 No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/parser768531.types b/tests/baselines/reference/parser768531.types
index f1bcedefae9..434535b5cc9 100644
--- a/tests/baselines/reference/parser768531.types
+++ b/tests/baselines/reference/parser768531.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts ===
+
 {a: 3}
 >a : any
 >3 : number
diff --git a/tests/baselines/reference/parserAccessors1.errors.txt b/tests/baselines/reference/parserAccessors1.errors.txt
index 8c5033da0c4..2ef8d4e37ab 100644
--- a/tests/baselines/reference/parserAccessors1.errors.txt
+++ b/tests/baselines/reference/parserAccessors1.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors1.ts(2,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors1.ts(2,9): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors1.ts (1 errors) ====
     class C {
         get Foo() { }
             ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserAccessors10.errors.txt b/tests/baselines/reference/parserAccessors10.errors.txt
index a5228f47443..d6a2b99eaca 100644
--- a/tests/baselines/reference/parserAccessors10.errors.txt
+++ b/tests/baselines/reference/parserAccessors10.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors10.ts(2,14): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors10.ts(2,14): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors10.ts (1 errors) ====
     var v = {
       public get foo() { }
                  ~~~
-!!! 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.
     };
\ No newline at end of file
diff --git a/tests/baselines/reference/parserAccessors3.errors.txt b/tests/baselines/reference/parserAccessors3.errors.txt
index 2987b606451..5411cd544eb 100644
--- a/tests/baselines/reference/parserAccessors3.errors.txt
+++ b/tests/baselines/reference/parserAccessors3.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts(1,15): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts (1 errors) ====
     var v = { get Foo() { } };
                   ~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
\ No newline at end of file
+!!! error TS2378: A 'get' accessor must return a value.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserAccessors7.errors.txt b/tests/baselines/reference/parserAccessors7.errors.txt
index 857833a7673..3938280e6d5 100644
--- a/tests/baselines/reference/parserAccessors7.errors.txt
+++ b/tests/baselines/reference/parserAccessors7.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): error TS1054: A 'get' accessor cannot have parameters.
-tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts (2 errors) ====
@@ -7,4 +7,4 @@ tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15):
                   ~~~
 !!! error TS1054: A 'get' accessor cannot have parameters.
                   ~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
\ No newline at end of file
+!!! error TS2378: A 'get' accessor must return a value.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserComputedPropertyName4.errors.txt b/tests/baselines/reference/parserComputedPropertyName4.errors.txt
index bfc78b162fd..3430e75b82f 100644
--- a/tests/baselines/reference/parserComputedPropertyName4.errors.txt
+++ b/tests/baselines/reference/parserComputedPropertyName4.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts(1,16): error TS2304: Cannot find name 'e'.
 
 
 ==== tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts (2 errors) ====
     var v = { get [e]() { } };
                   ~~~
-!!! 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 TS2304: Cannot find name 'e'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserComputedPropertyName5.errors.txt b/tests/baselines/reference/parserComputedPropertyName5.errors.txt
index 07cc6f3a9f0..09c38ecbef5 100644
--- a/tests/baselines/reference/parserComputedPropertyName5.errors.txt
+++ b/tests/baselines/reference/parserComputedPropertyName5.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts(1,22): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts(1,22): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts(1,23): error TS2304: Cannot find name 'e'.
 
 
 ==== tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts (2 errors) ====
     var v = { public get [e]() { } };
                          ~~~
-!!! 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 TS2304: Cannot find name 'e'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserES3Accessors1.errors.txt b/tests/baselines/reference/parserES3Accessors1.errors.txt
index 5e2ca9f97bc..9c6dbf0e76f 100644
--- a/tests/baselines/reference/parserES3Accessors1.errors.txt
+++ b/tests/baselines/reference/parserES3Accessors1.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9)
             ~~~
 !!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserES3Accessors3.errors.txt b/tests/baselines/reference/parserES3Accessors3.errors.txt
index 6d262e2a855..70ab3f2072e 100644
--- a/tests/baselines/reference/parserES3Accessors3.errors.txt
+++ b/tests/baselines/reference/parserES3Accessors3.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts (2 errors) ====
@@ -7,4 +7,4 @@ tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15
                   ~~~
 !!! 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.
\ No newline at end of file
+!!! error TS2378: A 'get' accessor must return a value.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt b/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt
index cfb12152c94..854bb364842 100644
--- a/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt
+++ b/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts(1,16): error TS2304: Cannot find name 'e'.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts (2 errors) ====
     var v = { get [e]() { } };
                   ~~~
-!!! 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 TS2304: Cannot find name 'e'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserES5ForOfStatement10.js b/tests/baselines/reference/parserES5ForOfStatement10.js
index cac70523022..36c505b0a12 100644
--- a/tests/baselines/reference/parserES5ForOfStatement10.js
+++ b/tests/baselines/reference/parserES5ForOfStatement10.js
@@ -3,6 +3,6 @@ for (const v of X) {
 }
 
 //// [parserES5ForOfStatement10.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var v = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var v = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement11.js b/tests/baselines/reference/parserES5ForOfStatement11.js
index 40e4ca68d6b..e3bac1584fc 100644
--- a/tests/baselines/reference/parserES5ForOfStatement11.js
+++ b/tests/baselines/reference/parserES5ForOfStatement11.js
@@ -3,6 +3,6 @@ for (const [a, b] of X) {
 }
 
 //// [parserES5ForOfStatement11.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i], a = _a[0], b = _a[1];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i], a = _a[0], b = _a[1];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement12.js b/tests/baselines/reference/parserES5ForOfStatement12.js
index f877ebdb757..2a43ca2dea3 100644
--- a/tests/baselines/reference/parserES5ForOfStatement12.js
+++ b/tests/baselines/reference/parserES5ForOfStatement12.js
@@ -3,6 +3,6 @@ for (const {a, b} of X) {
 }
 
 //// [parserES5ForOfStatement12.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i], a = _a.a, b = _a.b;
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i], a = _a.a, b = _a.b;
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement13.js b/tests/baselines/reference/parserES5ForOfStatement13.js
index 45199480518..2f1f280090f 100644
--- a/tests/baselines/reference/parserES5ForOfStatement13.js
+++ b/tests/baselines/reference/parserES5ForOfStatement13.js
@@ -3,6 +3,6 @@ for (let {a, b} of X) {
 }
 
 //// [parserES5ForOfStatement13.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i], a = _a.a, b = _a.b;
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i], a = _a.a, b = _a.b;
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement14.js b/tests/baselines/reference/parserES5ForOfStatement14.js
index d05fdb96e57..cb753328937 100644
--- a/tests/baselines/reference/parserES5ForOfStatement14.js
+++ b/tests/baselines/reference/parserES5ForOfStatement14.js
@@ -3,6 +3,6 @@ for (let [a, b] of X) {
 }
 
 //// [parserES5ForOfStatement14.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i], a = _a[0], b = _a[1];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i], a = _a[0], b = _a[1];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement15.js b/tests/baselines/reference/parserES5ForOfStatement15.js
index 0af74961145..c7c4db351a6 100644
--- a/tests/baselines/reference/parserES5ForOfStatement15.js
+++ b/tests/baselines/reference/parserES5ForOfStatement15.js
@@ -3,6 +3,6 @@ for (var [a, b] of X) {
 }
 
 //// [parserES5ForOfStatement15.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i], a = _a[0], b = _a[1];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i], a = _a[0], b = _a[1];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement16.js b/tests/baselines/reference/parserES5ForOfStatement16.js
index 1e7c6e005a8..149b6ce3df7 100644
--- a/tests/baselines/reference/parserES5ForOfStatement16.js
+++ b/tests/baselines/reference/parserES5ForOfStatement16.js
@@ -3,6 +3,6 @@ for (var {a, b} of X) {
 }
 
 //// [parserES5ForOfStatement16.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i], a = _a.a, b = _a.b;
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i], a = _a.a, b = _a.b;
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement18.js b/tests/baselines/reference/parserES5ForOfStatement18.js
index 905ba9c1d1e..0427adb52d8 100644
--- a/tests/baselines/reference/parserES5ForOfStatement18.js
+++ b/tests/baselines/reference/parserES5ForOfStatement18.js
@@ -2,6 +2,6 @@
 for (var of of of) { }
 
 //// [parserES5ForOfStatement18.js]
-for (var _i = 0; _i < of.length; _i++) {
-    var of = of[_i];
+for (var _i = 0, of_1 = of; _i < of_1.length; _i++) {
+    var of = of_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement2.js b/tests/baselines/reference/parserES5ForOfStatement2.js
index 287602dfb9c..43b557d9c8f 100644
--- a/tests/baselines/reference/parserES5ForOfStatement2.js
+++ b/tests/baselines/reference/parserES5ForOfStatement2.js
@@ -3,6 +3,6 @@ for (var of X) {
 }
 
 //// [parserES5ForOfStatement2.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var _a = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var _a = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement21.js b/tests/baselines/reference/parserES5ForOfStatement21.js
index dcdffbc3cf0..e5d7ebcac21 100644
--- a/tests/baselines/reference/parserES5ForOfStatement21.js
+++ b/tests/baselines/reference/parserES5ForOfStatement21.js
@@ -2,6 +2,6 @@
 for (var of of) { }
 
 //// [parserES5ForOfStatement21.js]
-for (var _i = 0; _i < of.length; _i++) {
-    var _a = of[_i];
+for (var _i = 0, of_1 = of; _i < of_1.length; _i++) {
+    var _a = of_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement3.js b/tests/baselines/reference/parserES5ForOfStatement3.js
index a99e96a23b8..953a59fb9b8 100644
--- a/tests/baselines/reference/parserES5ForOfStatement3.js
+++ b/tests/baselines/reference/parserES5ForOfStatement3.js
@@ -3,6 +3,6 @@ for (var a, b of X) {
 }
 
 //// [parserES5ForOfStatement3.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var a = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var a = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement4.js b/tests/baselines/reference/parserES5ForOfStatement4.js
index f1558005f20..8ad35187e51 100644
--- a/tests/baselines/reference/parserES5ForOfStatement4.js
+++ b/tests/baselines/reference/parserES5ForOfStatement4.js
@@ -3,6 +3,6 @@ for (var a = 1 of X) {
 }
 
 //// [parserES5ForOfStatement4.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var a = 1 = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var a = 1 = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement5.js b/tests/baselines/reference/parserES5ForOfStatement5.js
index 328b2fba0a7..3138b05e499 100644
--- a/tests/baselines/reference/parserES5ForOfStatement5.js
+++ b/tests/baselines/reference/parserES5ForOfStatement5.js
@@ -3,6 +3,6 @@ for (var a: number of X) {
 }
 
 //// [parserES5ForOfStatement5.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var a = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var a = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement6.js b/tests/baselines/reference/parserES5ForOfStatement6.js
index 15747b93ba9..75454de208e 100644
--- a/tests/baselines/reference/parserES5ForOfStatement6.js
+++ b/tests/baselines/reference/parserES5ForOfStatement6.js
@@ -3,6 +3,6 @@ for (var a = 1, b = 2 of X) {
 }
 
 //// [parserES5ForOfStatement6.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var a = 1 = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var a = 1 = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement7.js b/tests/baselines/reference/parserES5ForOfStatement7.js
index 29e4de8787f..ef3a02e45eb 100644
--- a/tests/baselines/reference/parserES5ForOfStatement7.js
+++ b/tests/baselines/reference/parserES5ForOfStatement7.js
@@ -3,6 +3,6 @@ for (var a: number = 1, b: string = "" of X) {
 }
 
 //// [parserES5ForOfStatement7.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var a = 1 = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var a = 1 = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement8.js b/tests/baselines/reference/parserES5ForOfStatement8.js
index 5c449fc6433..7aa61972601 100644
--- a/tests/baselines/reference/parserES5ForOfStatement8.js
+++ b/tests/baselines/reference/parserES5ForOfStatement8.js
@@ -3,6 +3,6 @@ for (var v of X) {
 }
 
 //// [parserES5ForOfStatement8.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var v = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var v = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserES5ForOfStatement9.js b/tests/baselines/reference/parserES5ForOfStatement9.js
index 6b63d58a88a..8202d2812c1 100644
--- a/tests/baselines/reference/parserES5ForOfStatement9.js
+++ b/tests/baselines/reference/parserES5ForOfStatement9.js
@@ -3,6 +3,6 @@ for (let v of X) {
 }
 
 //// [parserES5ForOfStatement9.js]
-for (var _i = 0; _i < X.length; _i++) {
-    var v = X[_i];
+for (var _i = 0, X_1 = X; _i < X_1.length; _i++) {
+    var v = X_1[_i];
 }
diff --git a/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt b/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt
index 9d391e39007..e6033d05215 100644
--- a/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt
+++ b/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt
@@ -1,18 +1,18 @@
-tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(2,18): 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/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(2,18): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(4,5): error TS1128: Declaration or statement expected.
-tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(4,18): 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/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(4,18): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts (3 errors) ====
     class C  {
         private a(): boolean {
                      ~~~~~~~
-!!! 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.
     
         private b(): boolean {
         ~~~~~~~
 !!! error TS1128: Declaration or statement 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.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt b/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt
index 4b8be3e17ad..05b31b7af8e 100644
--- a/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt
+++ b/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt
@@ -1,13 +1,16 @@
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts(2,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts(3,1): error TS7027: Unreachable code detected.
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts(4,1): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts (2 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts (3 errors) ====
     return foo;
     }
     ~
 !!! error TS1128: Declaration or statement expected.
     return bar;
+    ~~~~~~
+!!! error TS7027: Unreachable code detected.
     }
     ~
 !!! error TS1128: Declaration or statement expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt b/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt
index 0cf731cb516..09502f6b888 100644
--- a/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt
+++ b/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts(2,7): error TS1094: An accessor cannot have type parameters.
-tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts(2,7): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypePa
           ~~~
 !!! error TS1094: An accessor cannot have type parameters.
           ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserLabeledStatement1.d.errors.txt b/tests/baselines/reference/parserLabeledStatement1.d.errors.txt
index 11de61548a3..2ce51b0bb4c 100644
--- a/tests/baselines/reference/parserLabeledStatement1.d.errors.txt
+++ b/tests/baselines/reference/parserLabeledStatement1.d.errors.txt
@@ -1,11 +1,14 @@
 tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts(1,1): error TS1036: Statements are not allowed in ambient contexts.
+tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts(1,1): error TS7028: Unused label.
 tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts(2,3): error TS2304: Cannot find name 'bar'.
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts (2 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts (3 errors) ====
     foo:
     ~~~
 !!! error TS1036: Statements are not allowed in ambient contexts.
+    ~~~
+!!! error TS7028: Unused label.
       bar();
       ~~~
 !!! error TS2304: Cannot find name 'bar'.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessor1.errors.txt b/tests/baselines/reference/parserMemberAccessor1.errors.txt
index aa7cdcdafa3..2a3fd7d7028 100644
--- a/tests/baselines/reference/parserMemberAccessor1.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessor1.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessor1.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessor1.ts(2,7): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessor1.ts (1 errors) ====
     class C {
       get foo() { }
           ~~~
-!!! 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 foo(a) { }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt
index ac96e7d94b7..c2db31a5398 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration1.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration1.ts(2,7): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration1.ts (1 errors) ====
     class C {
       get a() { }
           ~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt
index 9a04674d6d7..ece110db165 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts(2,5): error TS1031: 'export' modifier cannot appear on a class element.
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts(2,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts(2,16): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb
         ~~~~~~
 !!! error TS1031: 'export' modifier cannot appear on a class element.
                    ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt
index 0d14a2adab8..a4ea29518d1 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts(2,8): error TS1054: A 'get' accessor cannot have parameters.
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts(2,8): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts(2,8): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb
            ~~~
 !!! error TS1054: A 'get' accessor cannot have parameters.
            ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt
index 69e87dff659..7b66bee844f 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration2.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration2.ts(2,7): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration2.ts (1 errors) ====
     class C {
       get "b"() { }
           ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt
index 93a1a5d14e1..a37fe230f76 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt
@@ -1,9 +1,9 @@
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration3.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration3.ts(2,7): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration3.ts (1 errors) ====
     class C {
       get 0() { }
           ~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt
index b7f67da49b7..2b0bd40a4f2 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts(2,12): error TS1028: Accessibility modifier already seen.
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts(2,23): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts(2,23): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb
                ~~~~~~
 !!! error TS1028: Accessibility modifier already seen.
                           ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt
index e5a39c149f6..67ba09b8c72 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts(2,12): error TS1030: 'static' modifier already seen.
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts(2,23): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts(2,23): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb
                ~~~~~~
 !!! error TS1030: 'static' modifier already seen.
                           ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt
index 2da32a5807b..31d001aeafc 100644
--- a/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt
+++ b/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt
@@ -1,5 +1,5 @@
 tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts(2,12): error TS1029: 'public' modifier must precede 'static' modifier.
-tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts(2,23): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts(2,23): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts (2 errors) ====
@@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb
                ~~~~~~
 !!! error TS1029: 'public' modifier must precede 'static' modifier.
                           ~~~
-!!! 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.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserParameterList5.errors.txt b/tests/baselines/reference/parserParameterList5.errors.txt
index 231a5bbb162..5f0899fa1a2 100644
--- a/tests/baselines/reference/parserParameterList5.errors.txt
+++ b/tests/baselines/reference/parserParameterList5.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.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/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,16): error TS2369: A parameter property is only allowed in a constructor implementation.
 tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,29): error TS2304: Cannot find name 'C'.
 
@@ -6,7 +6,7 @@ tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.t
 ==== tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.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.
                                 ~
diff --git a/tests/baselines/reference/parser_breakTarget3.js b/tests/baselines/reference/parser_breakTarget3.js
index 0eceba87bf8..91ba9fb5993 100644
--- a/tests/baselines/reference/parser_breakTarget3.js
+++ b/tests/baselines/reference/parser_breakTarget3.js
@@ -1,4 +1,5 @@
 //// [parser_breakTarget3.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/parser_breakTarget3.symbols b/tests/baselines/reference/parser_breakTarget3.symbols
index 99ec413987a..35184471d4d 100644
--- a/tests/baselines/reference/parser_breakTarget3.symbols
+++ b/tests/baselines/reference/parser_breakTarget3.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_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;
diff --git a/tests/baselines/reference/parser_breakTarget3.types b/tests/baselines/reference/parser_breakTarget3.types
index 7cdcb74d7da..b1ce9f8d94d 100644
--- a/tests/baselines/reference/parser_breakTarget3.types
+++ b/tests/baselines/reference/parser_breakTarget3.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/parser_breakTarget4.js b/tests/baselines/reference/parser_breakTarget4.js
index c6cadb5efa1..4516cf3e8f9 100644
--- a/tests/baselines/reference/parser_breakTarget4.js
+++ b/tests/baselines/reference/parser_breakTarget4.js
@@ -1,4 +1,5 @@
 //// [parser_breakTarget4.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/parser_breakTarget4.symbols b/tests/baselines/reference/parser_breakTarget4.symbols
index 042df67d9b2..f4d4b2e4bff 100644
--- a/tests/baselines/reference/parser_breakTarget4.symbols
+++ b/tests/baselines/reference/parser_breakTarget4.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_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;
diff --git a/tests/baselines/reference/parser_breakTarget4.types b/tests/baselines/reference/parser_breakTarget4.types
index 7315175800e..04bb129c919 100644
--- a/tests/baselines/reference/parser_breakTarget4.types
+++ b/tests/baselines/reference/parser_breakTarget4.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/parser_breakTarget5.errors.txt b/tests/baselines/reference/parser_breakTarget5.errors.txt
index 8221cbebb4c..5943649c97b 100644
--- a/tests/baselines/reference/parser_breakTarget5.errors.txt
+++ b/tests/baselines/reference/parser_breakTarget5.errors.txt
@@ -1,8 +1,11 @@
+tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts(1,1): error TS7028: Unused label.
 tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary.
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts (2 errors) ====
     target:
+    ~~~~~~
+!!! error TS7028: Unused label.
     while (true) {
       function f() {
         while (true) {
diff --git a/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt
index efade17a52a..94392259568 100644
--- a/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt
+++ b/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt
@@ -1,8 +1,11 @@
+tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts(1,1): error TS7028: Unused label.
 tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary.
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts (2 errors) ====
     TWO:
+    ~~~
+!!! error TS7028: Unused label.
     while (true){
       var x = () => {
         continue TWO;
diff --git a/tests/baselines/reference/parser_continueTarget3.js b/tests/baselines/reference/parser_continueTarget3.js
index 76a98a0e204..ea1559346de 100644
--- a/tests/baselines/reference/parser_continueTarget3.js
+++ b/tests/baselines/reference/parser_continueTarget3.js
@@ -1,4 +1,5 @@
 //// [parser_continueTarget3.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/parser_continueTarget3.symbols b/tests/baselines/reference/parser_continueTarget3.symbols
index 2038671d215..c522444ca1a 100644
--- a/tests/baselines/reference/parser_continueTarget3.symbols
+++ b/tests/baselines/reference/parser_continueTarget3.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_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;
diff --git a/tests/baselines/reference/parser_continueTarget3.types b/tests/baselines/reference/parser_continueTarget3.types
index 33c931c7959..fd8aedc357f 100644
--- a/tests/baselines/reference/parser_continueTarget3.types
+++ b/tests/baselines/reference/parser_continueTarget3.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/parser_continueTarget4.js b/tests/baselines/reference/parser_continueTarget4.js
index 795cab2e2ad..9ccaaac27e7 100644
--- a/tests/baselines/reference/parser_continueTarget4.js
+++ b/tests/baselines/reference/parser_continueTarget4.js
@@ -1,4 +1,5 @@
 //// [parser_continueTarget4.ts]
+
 target1:
 target2:
 while (true) {
diff --git a/tests/baselines/reference/parser_continueTarget4.symbols b/tests/baselines/reference/parser_continueTarget4.symbols
index 2b47099715e..b7e770f9bf9 100644
--- a/tests/baselines/reference/parser_continueTarget4.symbols
+++ b/tests/baselines/reference/parser_continueTarget4.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_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;
diff --git a/tests/baselines/reference/parser_continueTarget4.types b/tests/baselines/reference/parser_continueTarget4.types
index cb0367283ce..be1e5458f4b 100644
--- a/tests/baselines/reference/parser_continueTarget4.types
+++ b/tests/baselines/reference/parser_continueTarget4.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts ===
+
 target1:
 >target1 : any
 
diff --git a/tests/baselines/reference/parser_continueTarget5.errors.txt b/tests/baselines/reference/parser_continueTarget5.errors.txt
index ffeee7a07b3..b9b1f2edb94 100644
--- a/tests/baselines/reference/parser_continueTarget5.errors.txt
+++ b/tests/baselines/reference/parser_continueTarget5.errors.txt
@@ -1,8 +1,11 @@
+tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts(1,1): error TS7028: Unused label.
 tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary.
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts (2 errors) ====
     target:
+    ~~~~~~
+!!! error TS7028: Unused label.
     while (true) {
       function f() {
         while (true) {
diff --git a/tests/baselines/reference/parser_duplicateLabel1.errors.txt b/tests/baselines/reference/parser_duplicateLabel1.errors.txt
index 4733a240e36..a4319aaa7b9 100644
--- a/tests/baselines/reference/parser_duplicateLabel1.errors.txt
+++ b/tests/baselines/reference/parser_duplicateLabel1.errors.txt
@@ -1,8 +1,11 @@
+tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts(1,1): error TS7028: Unused label.
 tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target'
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts (2 errors) ====
     target:
+    ~~~~~~
+!!! error TS7028: Unused label.
     target:
     ~~~~~~
 !!! error TS1114: Duplicate label 'target'
diff --git a/tests/baselines/reference/parser_duplicateLabel2.errors.txt b/tests/baselines/reference/parser_duplicateLabel2.errors.txt
index 92078593e47..123949fa5aa 100644
--- a/tests/baselines/reference/parser_duplicateLabel2.errors.txt
+++ b/tests/baselines/reference/parser_duplicateLabel2.errors.txt
@@ -1,8 +1,11 @@
+tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts(1,1): error TS7028: Unused label.
 tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target'
 
 
-==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts (2 errors) ====
     target:
+    ~~~~~~
+!!! error TS7028: Unused label.
     while (true) {
       target:
       ~~~~~~
diff --git a/tests/baselines/reference/parser_duplicateLabel3.js b/tests/baselines/reference/parser_duplicateLabel3.js
index 9bd6c56356a..c2ea2769f18 100644
--- a/tests/baselines/reference/parser_duplicateLabel3.js
+++ b/tests/baselines/reference/parser_duplicateLabel3.js
@@ -1,4 +1,5 @@
 //// [parser_duplicateLabel3.ts]
+
 target:
 while (true) {
   function f() {
diff --git a/tests/baselines/reference/parser_duplicateLabel3.symbols b/tests/baselines/reference/parser_duplicateLabel3.symbols
index 20627a0e2b8..7e238eb2916 100644
--- a/tests/baselines/reference/parser_duplicateLabel3.symbols
+++ b/tests/baselines/reference/parser_duplicateLabel3.symbols
@@ -1,8 +1,9 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts ===
+
 target:
 while (true) {
   function f() {
->f : Symbol(f, Decl(parser_duplicateLabel3.ts, 1, 14))
+>f : Symbol(f, Decl(parser_duplicateLabel3.ts, 2, 14))
 
     target:
     while (true) {
diff --git a/tests/baselines/reference/parser_duplicateLabel3.types b/tests/baselines/reference/parser_duplicateLabel3.types
index 05cfe708161..88ea435bf3e 100644
--- a/tests/baselines/reference/parser_duplicateLabel3.types
+++ b/tests/baselines/reference/parser_duplicateLabel3.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts ===
+
 target:
 >target : any
 
diff --git a/tests/baselines/reference/parser_duplicateLabel4.js b/tests/baselines/reference/parser_duplicateLabel4.js
index 569a9bcd102..a9491314426 100644
--- a/tests/baselines/reference/parser_duplicateLabel4.js
+++ b/tests/baselines/reference/parser_duplicateLabel4.js
@@ -1,4 +1,5 @@
 //// [parser_duplicateLabel4.ts]
+
 target:
 while (true) {
 }
diff --git a/tests/baselines/reference/parser_duplicateLabel4.symbols b/tests/baselines/reference/parser_duplicateLabel4.symbols
index 564531bf71b..e7123de1600 100644
--- a/tests/baselines/reference/parser_duplicateLabel4.symbols
+++ b/tests/baselines/reference/parser_duplicateLabel4.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts ===
-target:
+
+No type information for this code.target:
 No type information for this code.while (true) {
 No type information for this code.}
 No type information for this code.
diff --git a/tests/baselines/reference/parser_duplicateLabel4.types b/tests/baselines/reference/parser_duplicateLabel4.types
index d09529301ca..b70dd12c695 100644
--- a/tests/baselines/reference/parser_duplicateLabel4.types
+++ b/tests/baselines/reference/parser_duplicateLabel4.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts ===
+
 target:
 >target : any
 
diff --git a/tests/baselines/reference/reachabilityChecks1.errors.txt b/tests/baselines/reference/reachabilityChecks1.errors.txt
new file mode 100644
index 00000000000..18a453969a1
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks1.errors.txt
@@ -0,0 +1,99 @@
+tests/cases/compiler/reachabilityChecks1.ts(3,1): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks1.ts(7,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks1.ts(19,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks1.ts(31,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks1.ts(48,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks1.ts(61,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks1.ts(70,5): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/compiler/reachabilityChecks1.ts (7 errors) ====
+    
+    while (true);
+    var x = 1;
+    ~~~
+!!! error TS7027: Unreachable code detected.
+    
+    module A {
+        while (true);
+        let x;
+        ~~~
+!!! error TS7027: Unreachable code detected.
+    }
+    
+    module A1 {
+        do {} while(true);
+        module A {
+            interface F {}
+        }
+    }
+    
+    module A2 {
+        while (true);
+        module A {
+        ~~~~~~
+!!! error TS7027: Unreachable code detected.
+            var x = 1;
+        }
+    }
+    
+    module A3 {
+        while (true);
+        type T = string;
+    }
+    
+    module A4 {
+        while (true);
+        module A {
+        ~~~~~~
+!!! error TS7027: Unreachable code detected.
+            const enum E { X }
+        }
+    }
+    
+    function f1(x) {
+        if (x) {
+            return;
+        }
+        else {
+            throw new Error("123");
+        }
+        var x;
+    }
+    
+    function f2() {
+        return;
+        class A {
+        ~~~~~
+!!! error TS7027: Unreachable code detected.
+        }
+    }
+    
+    module B {
+        for (; ;);
+        module C {
+        }
+    }
+    
+    function f3() {
+        do {
+        } while (true);
+        enum E {
+        ~~~~
+!!! error TS7027: Unreachable code detected.
+            X = 1
+        }
+    }
+    
+    function f4() {
+        if (true) {
+            throw new Error();
+        }
+        const enum E {
+        ~~~~~
+!!! error TS7027: Unreachable code detected.
+            X = 1
+        }
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/reachabilityChecks1.js b/tests/baselines/reference/reachabilityChecks1.js
new file mode 100644
index 00000000000..dcbfbe89de4
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks1.js
@@ -0,0 +1,156 @@
+//// [reachabilityChecks1.ts]
+
+while (true);
+var x = 1;
+
+module A {
+    while (true);
+    let x;
+}
+
+module A1 {
+    do {} while(true);
+    module A {
+        interface F {}
+    }
+}
+
+module A2 {
+    while (true);
+    module A {
+        var x = 1;
+    }
+}
+
+module A3 {
+    while (true);
+    type T = string;
+}
+
+module A4 {
+    while (true);
+    module A {
+        const enum E { X }
+    }
+}
+
+function f1(x) {
+    if (x) {
+        return;
+    }
+    else {
+        throw new Error("123");
+    }
+    var x;
+}
+
+function f2() {
+    return;
+    class A {
+    }
+}
+
+module B {
+    for (; ;);
+    module C {
+    }
+}
+
+function f3() {
+    do {
+    } while (true);
+    enum E {
+        X = 1
+    }
+}
+
+function f4() {
+    if (true) {
+        throw new Error();
+    }
+    const enum E {
+        X = 1
+    }
+}
+
+
+
+//// [reachabilityChecks1.js]
+while (true)
+    ;
+var x = 1;
+var A;
+(function (A) {
+    while (true)
+        ;
+    var x;
+})(A || (A = {}));
+var A1;
+(function (A1) {
+    do { } while (true);
+})(A1 || (A1 = {}));
+var A2;
+(function (A2) {
+    while (true)
+        ;
+    var A;
+    (function (A) {
+        var x = 1;
+    })(A || (A = {}));
+})(A2 || (A2 = {}));
+var A3;
+(function (A3) {
+    while (true)
+        ;
+})(A3 || (A3 = {}));
+var A4;
+(function (A4) {
+    while (true)
+        ;
+    var A;
+    (function (A) {
+        var E;
+        (function (E) {
+            E[E["X"] = 0] = "X";
+        })(E || (E = {}));
+    })(A || (A = {}));
+})(A4 || (A4 = {}));
+function f1(x) {
+    if (x) {
+        return;
+    }
+    else {
+        throw new Error("123");
+    }
+    var x;
+}
+function f2() {
+    return;
+    var A = (function () {
+        function A() {
+        }
+        return A;
+    })();
+}
+var B;
+(function (B) {
+    for (;;)
+        ;
+})(B || (B = {}));
+function f3() {
+    do {
+    } while (true);
+    var E;
+    (function (E) {
+        E[E["X"] = 1] = "X";
+    })(E || (E = {}));
+}
+function f4() {
+    if (true) {
+        throw new Error();
+    }
+    var E;
+    (function (E) {
+        E[E["X"] = 1] = "X";
+    })(E || (E = {}));
+}
diff --git a/tests/baselines/reference/reachabilityChecks2.errors.txt b/tests/baselines/reference/reachabilityChecks2.errors.txt
new file mode 100644
index 00000000000..cd48f84f8e1
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks2.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/compiler/reachabilityChecks2.ts(5,1): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/compiler/reachabilityChecks2.ts (1 errors) ====
+    
+    while (true) { }
+    const enum E { X }
+    
+    module A4 {
+    ~~~~~~
+!!! error TS7027: Unreachable code detected.
+        while (true);
+        module A {
+            const enum E { X }
+        }
+    }
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/reachabilityChecks2.js b/tests/baselines/reference/reachabilityChecks2.js
new file mode 100644
index 00000000000..a17b51b4ca6
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks2.js
@@ -0,0 +1,21 @@
+//// [reachabilityChecks2.ts]
+
+while (true) { }
+const enum E { X }
+
+module A4 {
+    while (true);
+    module A {
+        const enum E { X }
+    }
+}
+
+
+
+//// [reachabilityChecks2.js]
+while (true) { }
+var A4;
+(function (A4) {
+    while (true)
+        ;
+})(A4 || (A4 = {}));
diff --git a/tests/baselines/reference/reachabilityChecks3.errors.txt b/tests/baselines/reference/reachabilityChecks3.errors.txt
new file mode 100644
index 00000000000..1114f245f44
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks3.errors.txt
@@ -0,0 +1,27 @@
+tests/cases/compiler/reachabilityChecks3.ts(3,1): error TS7028: Unused label.
+tests/cases/compiler/reachabilityChecks3.ts(12,5): error TS7028: Unused label.
+tests/cases/compiler/reachabilityChecks3.ts(15,17): error TS7028: Unused label.
+
+
+==== tests/cases/compiler/reachabilityChecks3.ts (3 errors) ====
+    
+    let x = 1;
+    loop: while (true) {
+    ~~~~
+!!! error TS7028: Unused label.
+        if (x == 100) {
+            break;
+        }
+        else {
+            x++;
+        }
+    }
+    {
+        x: 100
+        ~
+!!! error TS7028: Unused label.
+    }
+    
+    var y = () => { f: 1 }
+                    ~
+!!! error TS7028: Unused label.
\ No newline at end of file
diff --git a/tests/baselines/reference/reachabilityChecks3.js b/tests/baselines/reference/reachabilityChecks3.js
new file mode 100644
index 00000000000..dd22453938d
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks3.js
@@ -0,0 +1,31 @@
+//// [reachabilityChecks3.ts]
+
+let x = 1;
+loop: while (true) {
+    if (x == 100) {
+        break;
+    }
+    else {
+        x++;
+    }
+}
+{
+    x: 100
+}
+
+var y = () => { f: 1 }
+
+//// [reachabilityChecks3.js]
+var x = 1;
+loop: while (true) {
+    if (x == 100) {
+        break;
+    }
+    else {
+        x++;
+    }
+}
+{
+    x: 100;
+}
+var y = function () { f: 1; };
diff --git a/tests/baselines/reference/reachabilityChecks4.errors.txt b/tests/baselines/reference/reachabilityChecks4.errors.txt
new file mode 100644
index 00000000000..ba9519462e7
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks4.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/compiler/reachabilityChecks4.ts(7,9): error TS7029: Fallthrough case in switch.
+
+
+==== tests/cases/compiler/reachabilityChecks4.ts (1 errors) ====
+    
+    function foo(x, y) {
+        switch (x) {
+            case 1:
+            case 2:
+                return 1;
+            case 3:
+            ~~~~
+!!! error TS7029: Fallthrough case in switch.
+                if (y) {
+                    return 2;
+                }
+            case 4:
+                return 3;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/reachabilityChecks4.js b/tests/baselines/reference/reachabilityChecks4.js
new file mode 100644
index 00000000000..588644c5a05
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks4.js
@@ -0,0 +1,30 @@
+//// [reachabilityChecks4.ts]
+
+function foo(x, y) {
+    switch (x) {
+        case 1:
+        case 2:
+            return 1;
+        case 3:
+            if (y) {
+                return 2;
+            }
+        case 4:
+            return 3;
+    }
+}
+
+//// [reachabilityChecks4.js]
+function foo(x, y) {
+    switch (x) {
+        case 1:
+        case 2:
+            return 1;
+        case 3:
+            if (y) {
+                return 2;
+            }
+        case 4:
+            return 3;
+    }
+}
diff --git a/tests/baselines/reference/reachabilityChecks5.errors.txt b/tests/baselines/reference/reachabilityChecks5.errors.txt
new file mode 100644
index 00000000000..147dbe264a3
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks5.errors.txt
@@ -0,0 +1,162 @@
+tests/cases/compiler/reachabilityChecks5.ts(6,17): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(19,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/reachabilityChecks5.ts(31,17): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(41,17): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(52,17): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(80,17): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(86,13): error TS7027: Unreachable code detected.
+tests/cases/compiler/reachabilityChecks5.ts(94,17): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(116,18): error TS7030: Not all code paths return a value.
+tests/cases/compiler/reachabilityChecks5.ts(123,13): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/compiler/reachabilityChecks5.ts (10 errors) ====
+    
+    function f0(x): number {
+        while (true);
+    }
+    
+    function f1(x): number {
+                    ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        if (x) {
+            return 1
+        }
+    }
+    
+    function f2(x): number {
+        while (x) {
+            throw new Error();
+        }
+        return 1;
+    }
+    
+    function f3(x): number {
+                    ~~~~~~
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+        while (x) {
+            throw new Error();
+        }
+    }
+    
+    function f3_1 (x): number {
+        while (x) {
+        }
+        throw new Error();
+    }
+    
+    function f4(x): number {
+                    ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        try {
+            if (x) {
+                return 1;
+            }
+        }
+        catch (e) {
+        }
+    }
+    
+    function f5(x): number {
+                    ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        try {
+            if (x) {
+                return 1;
+            }
+        }
+        catch (e) {
+            return 2;
+        }
+    }
+    
+    function f6(x): number {
+                    ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        try {
+            if (x) {
+                return 1;
+            }
+            else 
+            {
+                throw new Error();
+            }
+        }
+        catch (e) {
+        }
+    }
+    
+    function f7(x): number {
+        try {
+            if (x) {
+                return 1;
+            }
+            else {
+                throw new Error();
+            }
+        }
+        catch (e) {
+            return 1;
+        }
+    }
+    
+    function f8(x): number {
+                    ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        try {
+            if (true) {
+                x++;
+            }
+            else {
+                return 1;
+                ~~~~~~
+!!! error TS7027: Unreachable code detected.
+            }
+        }
+        catch (e) {
+            return 1;
+        }
+    }
+    
+    function f9(x): number {
+                    ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        try {
+            while (false) {
+                return 1;
+            }
+        }
+        catch (e) {
+            return 1;
+        }
+    }
+    
+    function f10(x): number {
+        try {
+            do {
+                x++;
+            } while (true);
+        }
+        catch (e) {
+            return 1;
+        }
+    }
+    
+    function f11(x): number {
+                     ~~~~~~
+!!! error TS7030: Not all code paths return a value.
+        test:
+        try {
+            do {
+                do {
+                    break test;
+                } while (true);
+                x++;
+                ~
+!!! error TS7027: Unreachable code detected.
+            } while (true);
+        }
+        catch (e) {
+            return 1;
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/reachabilityChecks5.js b/tests/baselines/reference/reachabilityChecks5.js
new file mode 100644
index 00000000000..a6c507ac87b
--- /dev/null
+++ b/tests/baselines/reference/reachabilityChecks5.js
@@ -0,0 +1,247 @@
+//// [reachabilityChecks5.ts]
+
+function f0(x): number {
+    while (true);
+}
+
+function f1(x): number {
+    if (x) {
+        return 1
+    }
+}
+
+function f2(x): number {
+    while (x) {
+        throw new Error();
+    }
+    return 1;
+}
+
+function f3(x): number {
+    while (x) {
+        throw new Error();
+    }
+}
+
+function f3_1 (x): number {
+    while (x) {
+    }
+    throw new Error();
+}
+
+function f4(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+    }
+    catch (e) {
+    }
+}
+
+function f5(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 2;
+    }
+}
+
+function f6(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+        else 
+        {
+            throw new Error();
+        }
+    }
+    catch (e) {
+    }
+}
+
+function f7(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+        else {
+            throw new Error();
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f8(x): number {
+    try {
+        if (true) {
+            x++;
+        }
+        else {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f9(x): number {
+    try {
+        while (false) {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f10(x): number {
+    try {
+        do {
+            x++;
+        } while (true);
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f11(x): number {
+    test:
+    try {
+        do {
+            do {
+                break test;
+            } while (true);
+            x++;
+        } while (true);
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+//// [reachabilityChecks5.js]
+function f0(x) {
+    while (true)
+        ;
+}
+function f1(x) {
+    if (x) {
+        return 1;
+    }
+}
+function f2(x) {
+    while (x) {
+        throw new Error();
+    }
+    return 1;
+}
+function f3(x) {
+    while (x) {
+        throw new Error();
+    }
+}
+function f3_1(x) {
+    while (x) {
+    }
+    throw new Error();
+}
+function f4(x) {
+    try {
+        if (x) {
+            return 1;
+        }
+    }
+    catch (e) {
+    }
+}
+function f5(x) {
+    try {
+        if (x) {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 2;
+    }
+}
+function f6(x) {
+    try {
+        if (x) {
+            return 1;
+        }
+        else {
+            throw new Error();
+        }
+    }
+    catch (e) {
+    }
+}
+function f7(x) {
+    try {
+        if (x) {
+            return 1;
+        }
+        else {
+            throw new Error();
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+function f8(x) {
+    try {
+        if (true) {
+            x++;
+        }
+        else {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+function f9(x) {
+    try {
+        while (false) {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+function f10(x) {
+    try {
+        do {
+            x++;
+        } while (true);
+    }
+    catch (e) {
+        return 1;
+    }
+}
+function f11(x) {
+    test: try {
+        do {
+            do {
+                break test;
+            } while (true);
+            x++;
+        } while (true);
+    }
+    catch (e) {
+        return 1;
+    }
+}
diff --git a/tests/baselines/reference/recursiveFunctionTypes.errors.txt b/tests/baselines/reference/recursiveFunctionTypes.errors.txt
index c69549403c4..8d5303c0669 100644
--- a/tests/baselines/reference/recursiveFunctionTypes.errors.txt
+++ b/tests/baselines/reference/recursiveFunctionTypes.errors.txt
@@ -2,8 +2,8 @@ tests/cases/compiler/recursiveFunctionTypes.ts(1,35): error TS2322: Type 'number
 tests/cases/compiler/recursiveFunctionTypes.ts(3,5): error TS2322: Type '() => typeof fn' is not assignable to type 'number'.
 tests/cases/compiler/recursiveFunctionTypes.ts(4,5): error TS2322: Type '() => typeof fn' is not assignable to type '() => number'.
   Type '() => typeof fn' is not assignable to type 'number'.
-tests/cases/compiler/recursiveFunctionTypes.ts(11,16): 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/recursiveFunctionTypes.ts(12,16): 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/recursiveFunctionTypes.ts(11,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/recursiveFunctionTypes.ts(12,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/recursiveFunctionTypes.ts(17,5): error TS2322: Type '() => I<typeof f3>' is not assignable to type 'number'.
 tests/cases/compiler/recursiveFunctionTypes.ts(22,5): error TS2345: Argument of type 'number' is not assignable to parameter of type '(t: typeof g) => void'.
 tests/cases/compiler/recursiveFunctionTypes.ts(25,1): error TS2322: Type 'number' is not assignable to type '() => any'.
@@ -34,10 +34,10 @@ tests/cases/compiler/recursiveFunctionTypes.ts(43,4): error TS2345: Argument of
     
     function f2(): typeof g2 { } 
                    ~~~~~~~~~
-!!! 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 g2(): typeof f2 { } 
                    ~~~~~~~~~
-!!! 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.
     
     interface I<T> { }
     function f3(): I<typeof f3> { return f3; }
diff --git a/tests/baselines/reference/recursiveLetConst.errors.txt b/tests/baselines/reference/recursiveLetConst.errors.txt
index b02d0819a3f..88ecb379e5e 100644
--- a/tests/baselines/reference/recursiveLetConst.errors.txt
+++ b/tests/baselines/reference/recursiveLetConst.errors.txt
@@ -3,6 +3,7 @@ tests/cases/compiler/recursiveLetConst.ts(3,12): error TS2448: Block-scoped vari
 tests/cases/compiler/recursiveLetConst.ts(4,11): error TS2448: Block-scoped variable 'y' used before its declaration.
 tests/cases/compiler/recursiveLetConst.ts(5,14): error TS2448: Block-scoped variable 'y1' used before its declaration.
 tests/cases/compiler/recursiveLetConst.ts(6,14): error TS2448: Block-scoped variable 'v' used before its declaration.
+tests/cases/compiler/recursiveLetConst.ts(7,1): error TS7027: Unreachable code detected.
 tests/cases/compiler/recursiveLetConst.ts(7,16): error TS2448: Block-scoped variable 'v' used before its declaration.
 tests/cases/compiler/recursiveLetConst.ts(8,15): error TS2448: Block-scoped variable 'v' used before its declaration.
 tests/cases/compiler/recursiveLetConst.ts(9,15): error TS2448: Block-scoped variable 'v' used before its declaration.
@@ -10,7 +11,7 @@ tests/cases/compiler/recursiveLetConst.ts(10,17): error TS2448: Block-scoped var
 tests/cases/compiler/recursiveLetConst.ts(11,11): error TS2448: Block-scoped variable 'x2' used before its declaration.
 
 
-==== tests/cases/compiler/recursiveLetConst.ts (10 errors) ====
+==== tests/cases/compiler/recursiveLetConst.ts (11 errors) ====
     'use strict'
     let x = x + 1;
             ~
@@ -28,6 +29,8 @@ tests/cases/compiler/recursiveLetConst.ts(11,11): error TS2448: Block-scoped var
                  ~
 !!! error TS2448: Block-scoped variable 'v' used before its declaration.
     for (let [v] = v; ;) { }
+    ~~~
+!!! error TS7027: Unreachable code detected.
                    ~
 !!! error TS2448: Block-scoped variable 'v' used before its declaration.
     for (let v in v) { }
diff --git a/tests/baselines/reference/recursiveMods.js b/tests/baselines/reference/recursiveMods.js
index 36d2712e040..f913ddec012 100644
--- a/tests/baselines/reference/recursiveMods.js
+++ b/tests/baselines/reference/recursiveMods.js
@@ -1,4 +1,5 @@
 //// [recursiveMods.ts]
+
 export module Foo {
 	export class C {}
 }
diff --git a/tests/baselines/reference/recursiveMods.symbols b/tests/baselines/reference/recursiveMods.symbols
index 1e7e8fa1c84..5f6d6f87721 100644
--- a/tests/baselines/reference/recursiveMods.symbols
+++ b/tests/baselines/reference/recursiveMods.symbols
@@ -1,44 +1,45 @@
 === tests/cases/compiler/recursiveMods.ts ===
+
 export module Foo {
->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1))
+>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1))
 
 	export class C {}
->C : Symbol(C, Decl(recursiveMods.ts, 0, 19))
+>C : Symbol(C, Decl(recursiveMods.ts, 1, 19))
 }
 
 export module Foo {
->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1))
+>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1))
 
 	function Bar() : C {
->Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19))
->C : Symbol(C, Decl(recursiveMods.ts, 0, 19))
+>Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19))
+>C : Symbol(C, Decl(recursiveMods.ts, 1, 19))
 
 		if (true) { return Bar();}
->Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19))
+>Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19))
 
 		return new C();
->C : Symbol(C, Decl(recursiveMods.ts, 0, 19))
+>C : Symbol(C, Decl(recursiveMods.ts, 1, 19))
 	}
 
 	function Baz() : C {
->Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2))
->C : Symbol(C, Decl(recursiveMods.ts, 0, 19))
+>Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2))
+>C : Symbol(C, Decl(recursiveMods.ts, 1, 19))
 
 		var c = Baz();
->c : Symbol(c, Decl(recursiveMods.ts, 12, 5))
->Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2))
+>c : Symbol(c, Decl(recursiveMods.ts, 13, 5))
+>Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2))
 
 		return Bar();
->Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19))
+>Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19))
 	}
 
 	function Gar() {
->Gar : Symbol(Gar, Decl(recursiveMods.ts, 14, 2))
+>Gar : Symbol(Gar, Decl(recursiveMods.ts, 15, 2))
 
 		var c : C = Baz();
->c : Symbol(c, Decl(recursiveMods.ts, 17, 5))
->C : Symbol(C, Decl(recursiveMods.ts, 0, 19))
->Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2))
+>c : Symbol(c, Decl(recursiveMods.ts, 18, 5))
+>C : Symbol(C, Decl(recursiveMods.ts, 1, 19))
+>Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2))
 
 		return;
 	}
diff --git a/tests/baselines/reference/recursiveMods.types b/tests/baselines/reference/recursiveMods.types
index d7f28f84975..d4db816daf7 100644
--- a/tests/baselines/reference/recursiveMods.types
+++ b/tests/baselines/reference/recursiveMods.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/recursiveMods.ts ===
+
 export module Foo {
 >Foo : typeof Foo
 
diff --git a/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt b/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt
index 7729d1e780f..04ddc371ac7 100644
--- a/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt
+++ b/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt
@@ -1,11 +1,12 @@
 tests/cases/compiler/recursiveNamedLambdaCall.ts(3,8): error TS2304: Cannot find name 'top'.
 tests/cases/compiler/recursiveNamedLambdaCall.ts(3,15): error TS2304: Cannot find name 'top'.
+tests/cases/compiler/recursiveNamedLambdaCall.ts(7,6): error TS7027: Unreachable code detected.
 tests/cases/compiler/recursiveNamedLambdaCall.ts(8,7): error TS2304: Cannot find name 'top'.
 tests/cases/compiler/recursiveNamedLambdaCall.ts(10,14): error TS2304: Cannot find name 'setTimeout'.
 tests/cases/compiler/recursiveNamedLambdaCall.ts(14,6): error TS2304: Cannot find name 'detach'.
 
 
-==== tests/cases/compiler/recursiveNamedLambdaCall.ts (5 errors) ====
+==== tests/cases/compiler/recursiveNamedLambdaCall.ts (6 errors) ====
     var promise = function( obj ) {
     	
     		if ( top && top.doScroll ) {
@@ -17,6 +18,8 @@ tests/cases/compiler/recursiveNamedLambdaCall.ts(14,6): error TS2304: Cannot fin
     				if ( false ) {
     
     					try {
+    					~~~
+!!! error TS7027: Unreachable code detected.
     						top.doScroll("left");
     						~~~
 !!! error TS2304: Cannot find name 'top'.
diff --git a/tests/baselines/reference/reservedWords2.errors.txt b/tests/baselines/reference/reservedWords2.errors.txt
index 090b2d0d43e..d6e2d04073d 100644
--- a/tests/baselines/reference/reservedWords2.errors.txt
+++ b/tests/baselines/reference/reservedWords2.errors.txt
@@ -14,6 +14,7 @@ tests/cases/compiler/reservedWords2.ts(5,9): error TS2300: Duplicate identifier
 tests/cases/compiler/reservedWords2.ts(5,10): error TS1003: Identifier expected.
 tests/cases/compiler/reservedWords2.ts(5,18): error TS1005: '=>' expected.
 tests/cases/compiler/reservedWords2.ts(6,1): error TS2304: Cannot find name 'module'.
+tests/cases/compiler/reservedWords2.ts(6,1): error TS7027: Unreachable code detected.
 tests/cases/compiler/reservedWords2.ts(6,8): error TS1005: ';' expected.
 tests/cases/compiler/reservedWords2.ts(7,11): error TS2300: Duplicate identifier '(Missing)'.
 tests/cases/compiler/reservedWords2.ts(7,11): error TS1005: ':' expected.
@@ -31,7 +32,7 @@ tests/cases/compiler/reservedWords2.ts(10,5): error TS2300: Duplicate identifier
 tests/cases/compiler/reservedWords2.ts(10,6): error TS1003: Identifier expected.
 
 
-==== tests/cases/compiler/reservedWords2.ts (31 errors) ====
+==== tests/cases/compiler/reservedWords2.ts (32 errors) ====
     import while = require("dfdf");
     ~~~~~~
 !!! error TS1148: Cannot compile modules unless the '--module' flag is provided.
@@ -70,6 +71,8 @@ tests/cases/compiler/reservedWords2.ts(10,6): error TS1003: Identifier expected.
     module void {}
     ~~~~~~
 !!! error TS2304: Cannot find name 'module'.
+    ~~~~~~
+!!! error TS7027: Unreachable code detected.
            ~~~~
 !!! error TS1005: ';' expected.
     var {while, return} = { while: 1, return: 2 };
diff --git a/tests/baselines/reference/returnStatement1.js b/tests/baselines/reference/returnStatement1.js
index c4ccc3cadde..3f5c5561b2a 100644
--- a/tests/baselines/reference/returnStatement1.js
+++ b/tests/baselines/reference/returnStatement1.js
@@ -1,4 +1,5 @@
 //// [returnStatement1.ts]
+
 function f() {
     return function (s) {
         var x = s;
diff --git a/tests/baselines/reference/returnStatement1.symbols b/tests/baselines/reference/returnStatement1.symbols
index acec9f76003..6727cba0df5 100644
--- a/tests/baselines/reference/returnStatement1.symbols
+++ b/tests/baselines/reference/returnStatement1.symbols
@@ -1,13 +1,14 @@
 === tests/cases/compiler/returnStatement1.ts ===
+
 function f() {
 >f : Symbol(f, Decl(returnStatement1.ts, 0, 0))
 
     return function (s) {
->s : Symbol(s, Decl(returnStatement1.ts, 1, 21))
+>s : Symbol(s, Decl(returnStatement1.ts, 2, 21))
 
         var x = s;
->x : Symbol(x, Decl(returnStatement1.ts, 2, 11))
->s : Symbol(s, Decl(returnStatement1.ts, 1, 21))
+>x : Symbol(x, Decl(returnStatement1.ts, 3, 11))
+>s : Symbol(s, Decl(returnStatement1.ts, 2, 21))
 
     };
     ("harmless extra line");
diff --git a/tests/baselines/reference/returnStatement1.types b/tests/baselines/reference/returnStatement1.types
index ff30148af5a..b7e166ffa75 100644
--- a/tests/baselines/reference/returnStatement1.types
+++ b/tests/baselines/reference/returnStatement1.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/returnStatement1.ts ===
+
 function f() {
 >f : () => (s: any) => void
 
diff --git a/tests/baselines/reference/returnTypeParameter.errors.txt b/tests/baselines/reference/returnTypeParameter.errors.txt
index 11c0888f47c..1bd9f6a63f6 100644
--- a/tests/baselines/reference/returnTypeParameter.errors.txt
+++ b/tests/baselines/reference/returnTypeParameter.errors.txt
@@ -1,11 +1,11 @@
-tests/cases/compiler/returnTypeParameter.ts(1,22): 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/returnTypeParameter.ts(1,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/returnTypeParameter.ts(2,34): error TS2304: Cannot find name 'T'.
 
 
 ==== tests/cases/compiler/returnTypeParameter.ts (2 errors) ====
     function f<T>(a: T): T { } // error, no return statement
                          ~
-!!! 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 f2<T>(a: T): T { return T; } // bug was that this satisfied the return statement requirement
                                      ~
 !!! error TS2304: Cannot find name 'T'.
\ No newline at end of file
diff --git a/tests/baselines/reference/scanner10.1.1-8gs.errors.txt b/tests/baselines/reference/scanner10.1.1-8gs.errors.txt
index 54cd92dc0ca..23d89cdf7ff 100644
--- a/tests/baselines/reference/scanner10.1.1-8gs.errors.txt
+++ b/tests/baselines/reference/scanner10.1.1-8gs.errors.txt
@@ -1,8 +1,9 @@
 tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'.
+tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(17,1): error TS7027: Unreachable code detected.
 tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode
 
 
-==== tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts (2 errors) ====
+==== tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts (3 errors) ====
     /// Copyright (c) 2012 Ecma International.  All rights reserved. 
     /// Ecma International makes this code available under the terms and conditions set
     /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
@@ -22,6 +23,8 @@ tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(17,5): error TS
           ~~~~~~~~~~~~~
 !!! error TS2304: Cannot find name 'NotEarlyError'.
     var public = 1;
+    ~~~
+!!! error TS7027: Unreachable code detected.
         ~~~~~~
 !!! error TS1212: Identifier expected. 'public' is a reserved word in strict mode
     
\ No newline at end of file
diff --git a/tests/baselines/reference/setterWithReturn.errors.txt b/tests/baselines/reference/setterWithReturn.errors.txt
index 481116327b8..6aed49105b8 100644
--- a/tests/baselines/reference/setterWithReturn.errors.txt
+++ b/tests/baselines/reference/setterWithReturn.errors.txt
@@ -1,9 +1,10 @@
 tests/cases/compiler/setterWithReturn.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/setterWithReturn.ts(4,20): error TS2408: Setters cannot return a value.
+tests/cases/compiler/setterWithReturn.ts(7,13): error TS7027: Unreachable code detected.
 tests/cases/compiler/setterWithReturn.ts(7,20): error TS2408: Setters cannot return a value.
 
 
-==== tests/cases/compiler/setterWithReturn.ts (3 errors) ====
+==== tests/cases/compiler/setterWithReturn.ts (4 errors) ====
     class C234 {
         public set p1(arg1) {
                    ~~
@@ -15,6 +16,8 @@ tests/cases/compiler/setterWithReturn.ts(7,20): error TS2408: Setters cannot ret
             }
             else {
                 return 0;
+                ~~~~~~
+!!! error TS7027: Unreachable code detected.
                        ~
 !!! error TS2408: Setters cannot return a value.
             }
diff --git a/tests/baselines/reference/sourceMapValidationFor.errors.txt b/tests/baselines/reference/sourceMapValidationFor.errors.txt
index 7fe75d640d2..6949d7545ed 100644
--- a/tests/baselines/reference/sourceMapValidationFor.errors.txt
+++ b/tests/baselines/reference/sourceMapValidationFor.errors.txt
@@ -1,8 +1,9 @@
 tests/cases/compiler/sourceMapValidationFor.ts(2,5): error TS2304: Cannot find name 'WScript'.
 tests/cases/compiler/sourceMapValidationFor.ts(6,5): error TS2304: Cannot find name 'WScript'.
+tests/cases/compiler/sourceMapValidationFor.ts(20,1): error TS7027: Unreachable code detected.
 
 
-==== tests/cases/compiler/sourceMapValidationFor.ts (2 errors) ====
+==== tests/cases/compiler/sourceMapValidationFor.ts (3 errors) ====
     for (var i = 0; i < 10; i++) {
         WScript.Echo("i: " + i);
         ~~~~~~~
@@ -27,6 +28,8 @@ tests/cases/compiler/sourceMapValidationFor.ts(6,5): error TS2304: Cannot find n
     for (var k = 0;; k++) {
     }
     for (k = 0;; k++)
+    ~~~
+!!! error TS7027: Unreachable code detected.
     {
     }
     for (; k < 10; k++) {
diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js b/tests/baselines/reference/sourceMapValidationLabeled.js
index 7aabc47ea4e..50669b870ab 100644
--- a/tests/baselines/reference/sourceMapValidationLabeled.js
+++ b/tests/baselines/reference/sourceMapValidationLabeled.js
@@ -1,4 +1,5 @@
 //// [sourceMapValidationLabeled.ts]
+
 x:
 var b = 10;
 
diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js.map b/tests/baselines/reference/sourceMapValidationLabeled.js.map
index d1219f9896f..206ac95b951 100644
--- a/tests/baselines/reference/sourceMapValidationLabeled.js.map
+++ b/tests/baselines/reference/sourceMapValidationLabeled.js.map
@@ -1,2 +1,2 @@
 //// [sourceMapValidationLabeled.js.map]
-{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AAAA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"}
\ No newline at end of file
+{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AACA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"}
\ No newline at end of file
diff --git a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt
index 007208c78f9..7cf1bf896ca 100644
--- a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt
+++ b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt
@@ -18,7 +18,8 @@ sourceFile:sourceMapValidationLabeled.ts
 7 >           ^^
 8 >             ^
 9 >              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
-1 >
+1 >
+  >
 2 >x
 3 > :
   > 
@@ -27,13 +28,13 @@ sourceFile:sourceMapValidationLabeled.ts
 6 >         = 
 7 >           10
 8 >             ;
-1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
-2 >Emitted(1, 2) Source(1, 2) + SourceIndex(0)
-3 >Emitted(1, 4) Source(2, 1) + SourceIndex(0)
-4 >Emitted(1, 8) Source(2, 5) + SourceIndex(0)
-5 >Emitted(1, 9) Source(2, 6) + SourceIndex(0)
-6 >Emitted(1, 12) Source(2, 9) + SourceIndex(0)
-7 >Emitted(1, 14) Source(2, 11) + SourceIndex(0)
-8 >Emitted(1, 15) Source(2, 12) + SourceIndex(0)
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 2) Source(2, 2) + SourceIndex(0)
+3 >Emitted(1, 4) Source(3, 1) + SourceIndex(0)
+4 >Emitted(1, 8) Source(3, 5) + SourceIndex(0)
+5 >Emitted(1, 9) Source(3, 6) + SourceIndex(0)
+6 >Emitted(1, 12) Source(3, 9) + SourceIndex(0)
+7 >Emitted(1, 14) Source(3, 11) + SourceIndex(0)
+8 >Emitted(1, 15) Source(3, 12) + SourceIndex(0)
 ---
 >>>//# sourceMappingURL=sourceMapValidationLabeled.js.map
\ No newline at end of file
diff --git a/tests/baselines/reference/sourceMapValidationLabeled.symbols b/tests/baselines/reference/sourceMapValidationLabeled.symbols
index 2a3c4f5606c..bf9abc593b3 100644
--- a/tests/baselines/reference/sourceMapValidationLabeled.symbols
+++ b/tests/baselines/reference/sourceMapValidationLabeled.symbols
@@ -1,5 +1,6 @@
 === tests/cases/compiler/sourceMapValidationLabeled.ts ===
+
 x:
 var b = 10;
->b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 1, 3))
+>b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 2, 3))
 
diff --git a/tests/baselines/reference/sourceMapValidationLabeled.types b/tests/baselines/reference/sourceMapValidationLabeled.types
index 3058869cb0b..7af624ac93b 100644
--- a/tests/baselines/reference/sourceMapValidationLabeled.types
+++ b/tests/baselines/reference/sourceMapValidationLabeled.types
@@ -1,4 +1,5 @@
 === tests/cases/compiler/sourceMapValidationLabeled.ts ===
+
 x:
 >x : any
 
diff --git a/tests/baselines/reference/switchBreakStatements.js b/tests/baselines/reference/switchBreakStatements.js
index 534f025e2f5..d7fa279248c 100644
--- a/tests/baselines/reference/switchBreakStatements.js
+++ b/tests/baselines/reference/switchBreakStatements.js
@@ -1,4 +1,5 @@
 //// [switchBreakStatements.ts]
+
 switch ('') {
     case 'a':
         break;
diff --git a/tests/baselines/reference/switchBreakStatements.symbols b/tests/baselines/reference/switchBreakStatements.symbols
index 22626241881..dde7ca028cc 100644
--- a/tests/baselines/reference/switchBreakStatements.symbols
+++ b/tests/baselines/reference/switchBreakStatements.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts ===
+
 switch ('') {
     case 'a':
         break;
@@ -48,7 +49,7 @@ switch ('') {
                         switch ('') {
                             case 'a':
                                 var fn = function () { }
->fn : Symbol(fn, Decl(switchBreakStatements.ts, 48, 35))
+>fn : Symbol(fn, Decl(switchBreakStatements.ts, 49, 35))
 
                                 break EIGHT;
                         }
diff --git a/tests/baselines/reference/switchBreakStatements.types b/tests/baselines/reference/switchBreakStatements.types
index c8847a5dc34..0364d878d5a 100644
--- a/tests/baselines/reference/switchBreakStatements.types
+++ b/tests/baselines/reference/switchBreakStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts ===
+
 switch ('') {
 >'' : string
 
diff --git a/tests/baselines/reference/thisTypeErrors2.errors.txt b/tests/baselines/reference/thisTypeErrors2.errors.txt
new file mode 100644
index 00000000000..783325f4ef3
--- /dev/null
+++ b/tests/baselines/reference/thisTypeErrors2.errors.txt
@@ -0,0 +1,23 @@
+tests/cases/conformance/types/thisType/thisTypeErrors2.ts(2,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+tests/cases/conformance/types/thisType/thisTypeErrors2.ts(9,38): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+
+
+==== tests/cases/conformance/types/thisType/thisTypeErrors2.ts (2 errors) ====
+    class Base {
+        constructor(a: this) {
+                       ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+        }
+    }
+    class Generic<T> {
+    }
+    class Derived {
+        n: number;
+        constructor(public host: Generic<this>) {
+                                         ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+            let self: this = this;
+            this.n = 12;
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/thisTypeErrors2.js b/tests/baselines/reference/thisTypeErrors2.js
new file mode 100644
index 00000000000..f48d0874e53
--- /dev/null
+++ b/tests/baselines/reference/thisTypeErrors2.js
@@ -0,0 +1,35 @@
+//// [thisTypeErrors2.ts]
+class Base {
+    constructor(a: this) {
+    }
+}
+class Generic<T> {
+}
+class Derived {
+    n: number;
+    constructor(public host: Generic<this>) {
+        let self: this = this;
+        this.n = 12;
+    }
+}
+
+
+//// [thisTypeErrors2.js]
+var Base = (function () {
+    function Base(a) {
+    }
+    return Base;
+})();
+var Generic = (function () {
+    function Generic() {
+    }
+    return Generic;
+})();
+var Derived = (function () {
+    function Derived(host) {
+        this.host = host;
+        var self = this;
+        this.n = 12;
+    }
+    return Derived;
+})();
diff --git a/tests/baselines/reference/thisTypeInClasses.errors.txt b/tests/baselines/reference/thisTypeInClasses.errors.txt
new file mode 100644
index 00000000000..db2ae1b5793
--- /dev/null
+++ b/tests/baselines/reference/thisTypeInClasses.errors.txt
@@ -0,0 +1,57 @@
+tests/cases/conformance/types/thisType/thisTypeInClasses.ts(4,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
+
+
+==== tests/cases/conformance/types/thisType/thisTypeInClasses.ts (1 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 {
+        [x: string]: this;
+    }
+    
+    interface Foo<T> {
+        x: T;
+        y: this;
+    }
+    
+    class C3 {
+        a: this[];
+        b: [this, this];
+        c: this | Date;
+        d: this & Date;
+        e: (((this)));
+        f: (x: this) => this;
+        g: new (x: this) => this;
+        h: Foo<this>;
+        i: Foo<this | (() => this)>;
+        j: (x: any) => x is this;
+    }
+    
+    declare class C4 {
+        x: this;
+        f(x: this): this;
+    }
+    
+    class C5 {
+        foo() {
+            let f1 = (x: this): this => this;
+            let f2 = (x: this) => this;
+            let f3 = (x: this) => (y: this) => this;
+            let f4 = (x: this) => {
+                let g = (y: this) => {
+                    return () => this;
+                }
+                return g(this);
+            }
+        }
+        bar() {
+            let x1 = <this>undefined;
+            let x2 = undefined as this;
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/throwInEnclosingStatements.js b/tests/baselines/reference/throwInEnclosingStatements.js
index 0b072434f33..4d9200776e7 100644
--- a/tests/baselines/reference/throwInEnclosingStatements.js
+++ b/tests/baselines/reference/throwInEnclosingStatements.js
@@ -1,4 +1,5 @@
 //// [throwInEnclosingStatements.ts]
+
 function fn(x) {
     throw x;
 }
diff --git a/tests/baselines/reference/throwInEnclosingStatements.symbols b/tests/baselines/reference/throwInEnclosingStatements.symbols
index 007894047de..42053c60efa 100644
--- a/tests/baselines/reference/throwInEnclosingStatements.symbols
+++ b/tests/baselines/reference/throwInEnclosingStatements.symbols
@@ -1,91 +1,92 @@
 === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts ===
+
 function fn(x) {
 >fn : Symbol(fn, Decl(throwInEnclosingStatements.ts, 0, 0))
->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12))
+>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12))
 
     throw x;
->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12))
+>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12))
 }
 
 <T>(x: T) => { throw x; }
->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1))
->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4))
->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1))
->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4))
+>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1))
+>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4))
+>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1))
+>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4))
 
 var y: string;
->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3))
+>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3))
 
 switch (y) {
->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3))
+>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3))
 
     case 'a':
         throw y;
->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3))
+>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3))
 
     default:
         throw y;
->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3))
+>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3))
 }
 
 var z = 0;
->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3))
+>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3))
 
 while (z < 10) {
->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3))
+>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3))
 
     throw z;
->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3))
+>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3))
 }
 
 for (var i = 0; ;) { throw i; }
->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8))
->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8))
+>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8))
+>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8))
 
 for (var idx in {}) { throw idx; }
->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8))
->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8))
+>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8))
+>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8))
 
 do { throw null; }while(true)
 
 var j = 0;
->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3))
+>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3))
 
 while (j < 0) { throw j; }
->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3))
->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3))
+>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3))
+>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3))
 
 class C<T> {
->C : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26))
->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8))
+>C : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26))
+>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8))
 
     private value: T;
->value : Symbol(value, Decl(throwInEnclosingStatements.ts, 28, 12))
->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8))
+>value : Symbol(value, Decl(throwInEnclosingStatements.ts, 29, 12))
+>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8))
 
     biz() {
->biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 29, 21))
+>biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 30, 21))
 
         throw this.value;
->this.value : Symbol(value, Decl(throwInEnclosingStatements.ts, 28, 12))
->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26))
->value : Symbol(value, Decl(throwInEnclosingStatements.ts, 28, 12))
+>this.value : Symbol(value, Decl(throwInEnclosingStatements.ts, 29, 12))
+>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26))
+>value : Symbol(value, Decl(throwInEnclosingStatements.ts, 29, 12))
     }
 
     constructor() {
         throw this;
->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26))
+>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26))
     }
 }
 
 var aa = {
->aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 39, 3))
+>aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 40, 3))
 
     id:12,
->id : Symbol(id, Decl(throwInEnclosingStatements.ts, 39, 10))
+>id : Symbol(id, Decl(throwInEnclosingStatements.ts, 40, 10))
 
     biz() {
->biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 40, 10))
+>biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 41, 10))
 
         throw this;
     }
diff --git a/tests/baselines/reference/throwInEnclosingStatements.types b/tests/baselines/reference/throwInEnclosingStatements.types
index bcff8653d52..568fd800e35 100644
--- a/tests/baselines/reference/throwInEnclosingStatements.types
+++ b/tests/baselines/reference/throwInEnclosingStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts ===
+
 function fn(x) {
 >fn : (x: any) => void
 >x : any
diff --git a/tests/baselines/reference/throwStatements.js b/tests/baselines/reference/throwStatements.js
index 83663d08cc4..556ebc55e37 100644
--- a/tests/baselines/reference/throwStatements.js
+++ b/tests/baselines/reference/throwStatements.js
@@ -1,4 +1,5 @@
 //// [throwStatements.ts]
+
 // all legal
 
 interface I {
diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols
index 508bdcb9f3f..adf9cb461cf 100644
--- a/tests/baselines/reference/throwStatements.symbols
+++ b/tests/baselines/reference/throwStatements.symbols
@@ -1,184 +1,185 @@
 === tests/cases/conformance/statements/throwStatements/throwStatements.ts ===
+
 // all legal
 
 interface I {
 >I : Symbol(I, Decl(throwStatements.ts, 0, 0))
 
     id: number;
->id : Symbol(id, Decl(throwStatements.ts, 2, 13))
+>id : Symbol(id, Decl(throwStatements.ts, 3, 13))
 }
 
 class C implements I {
->C : Symbol(C, Decl(throwStatements.ts, 4, 1))
+>C : Symbol(C, Decl(throwStatements.ts, 5, 1))
 >I : Symbol(I, Decl(throwStatements.ts, 0, 0))
 
     id: number;
->id : Symbol(id, Decl(throwStatements.ts, 6, 22))
+>id : Symbol(id, Decl(throwStatements.ts, 7, 22))
 }
 
 class D<T>{
->D : Symbol(D, Decl(throwStatements.ts, 8, 1))
->T : Symbol(T, Decl(throwStatements.ts, 10, 8))
+>D : Symbol(D, Decl(throwStatements.ts, 9, 1))
+>T : Symbol(T, Decl(throwStatements.ts, 11, 8))
 
     source: T;
->source : Symbol(source, Decl(throwStatements.ts, 10, 11))
->T : Symbol(T, Decl(throwStatements.ts, 10, 8))
+>source : Symbol(source, Decl(throwStatements.ts, 11, 11))
+>T : Symbol(T, Decl(throwStatements.ts, 11, 8))
 
     recurse: D<T>;
->recurse : Symbol(recurse, Decl(throwStatements.ts, 11, 14))
->D : Symbol(D, Decl(throwStatements.ts, 8, 1))
->T : Symbol(T, Decl(throwStatements.ts, 10, 8))
+>recurse : Symbol(recurse, Decl(throwStatements.ts, 12, 14))
+>D : Symbol(D, Decl(throwStatements.ts, 9, 1))
+>T : Symbol(T, Decl(throwStatements.ts, 11, 8))
 
     wrapped: D<D<T>>
->wrapped : Symbol(wrapped, Decl(throwStatements.ts, 12, 18))
->D : Symbol(D, Decl(throwStatements.ts, 8, 1))
->D : Symbol(D, Decl(throwStatements.ts, 8, 1))
->T : Symbol(T, Decl(throwStatements.ts, 10, 8))
+>wrapped : Symbol(wrapped, Decl(throwStatements.ts, 13, 18))
+>D : Symbol(D, Decl(throwStatements.ts, 9, 1))
+>D : Symbol(D, Decl(throwStatements.ts, 9, 1))
+>T : Symbol(T, Decl(throwStatements.ts, 11, 8))
 }
 
 function F(x: string): number { return 42; }
->F : Symbol(F, Decl(throwStatements.ts, 14, 1))
->x : Symbol(x, Decl(throwStatements.ts, 16, 11))
+>F : Symbol(F, Decl(throwStatements.ts, 15, 1))
+>x : Symbol(x, Decl(throwStatements.ts, 17, 11))
 
 module M {
->M : Symbol(M, Decl(throwStatements.ts, 16, 44))
+>M : Symbol(M, Decl(throwStatements.ts, 17, 44))
 
     export class A {
->A : Symbol(A, Decl(throwStatements.ts, 18, 10))
+>A : Symbol(A, Decl(throwStatements.ts, 19, 10))
 
         name: string;
->name : Symbol(name, Decl(throwStatements.ts, 19, 20))
+>name : Symbol(name, Decl(throwStatements.ts, 20, 20))
     }
 
     export function F2(x: number): string { return x.toString(); }
->F2 : Symbol(F2, Decl(throwStatements.ts, 21, 5))
->x : Symbol(x, Decl(throwStatements.ts, 23, 23))
+>F2 : Symbol(F2, Decl(throwStatements.ts, 22, 5))
+>x : Symbol(x, Decl(throwStatements.ts, 24, 23))
 >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(throwStatements.ts, 23, 23))
+>x : Symbol(x, Decl(throwStatements.ts, 24, 23))
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 }
 
 var aNumber = 9.9;
->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3))
+>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3))
 
 throw aNumber;
->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3))
+>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3))
 
 var aString = 'this is a string';
->aString : Symbol(aString, Decl(throwStatements.ts, 28, 3))
+>aString : Symbol(aString, Decl(throwStatements.ts, 29, 3))
 
 throw aString;
->aString : Symbol(aString, Decl(throwStatements.ts, 28, 3))
+>aString : Symbol(aString, Decl(throwStatements.ts, 29, 3))
 
 var aDate = new Date(12);
->aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3))
+>aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3))
 >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw aDate;
->aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3))
+>aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3))
 
 var anObject = new Object();
->anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3))
+>anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw anObject;
->anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3))
+>anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3))
 
 var anAny = null;
->anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3))
+>anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3))
 
 throw anAny;
->anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3))
+>anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3))
 
 var anOtherAny = <any> new C();
->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3))
->C : Symbol(C, Decl(throwStatements.ts, 4, 1))
+>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3))
+>C : Symbol(C, Decl(throwStatements.ts, 5, 1))
 
 throw anOtherAny;
->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3))
+>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3))
 
 var anUndefined = undefined;
->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3))
+>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3))
 >undefined : Symbol(undefined)
 
 throw anUndefined;
->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3))
+>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3))
 
 var aClass = new C();
->aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3))
->C : Symbol(C, Decl(throwStatements.ts, 4, 1))
+>aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3))
+>C : Symbol(C, Decl(throwStatements.ts, 5, 1))
 
 throw aClass;
->aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3))
+>aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3))
 
 var aGenericClass = new D<string>();
->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3))
->D : Symbol(D, Decl(throwStatements.ts, 8, 1))
+>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3))
+>D : Symbol(D, Decl(throwStatements.ts, 9, 1))
 
 throw aGenericClass;
->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3))
+>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3))
 
 var anObjectLiteral = { id: 12 };
->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3))
->id : Symbol(id, Decl(throwStatements.ts, 46, 23))
+>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3))
+>id : Symbol(id, Decl(throwStatements.ts, 47, 23))
 
 throw anObjectLiteral;
->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3))
+>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3))
 
 var aFunction = F;
->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3))
->F : Symbol(F, Decl(throwStatements.ts, 14, 1))
+>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3))
+>F : Symbol(F, Decl(throwStatements.ts, 15, 1))
 
 throw aFunction;
->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3))
+>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3))
 
 throw aFunction('');
->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3))
+>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3))
 
 var aLambda = (x) => 2;
->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3))
->x : Symbol(x, Decl(throwStatements.ts, 52, 15))
+>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3))
+>x : Symbol(x, Decl(throwStatements.ts, 53, 15))
 
 throw aLambda;
->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3))
+>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3))
 
 throw aLambda(1);
->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3))
+>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3))
 
 var aModule = M;
->aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3))
->M : Symbol(M, Decl(throwStatements.ts, 16, 44))
+>aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3))
+>M : Symbol(M, Decl(throwStatements.ts, 17, 44))
 
 throw aModule;
->aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3))
+>aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3))
 
 throw typeof M;
->M : Symbol(M, Decl(throwStatements.ts, 16, 44))
+>M : Symbol(M, Decl(throwStatements.ts, 17, 44))
 
 var aClassInModule = new M.A();
->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3))
->M.A : Symbol(M.A, Decl(throwStatements.ts, 18, 10))
->M : Symbol(M, Decl(throwStatements.ts, 16, 44))
->A : Symbol(M.A, Decl(throwStatements.ts, 18, 10))
+>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3))
+>M.A : Symbol(M.A, Decl(throwStatements.ts, 19, 10))
+>M : Symbol(M, Decl(throwStatements.ts, 17, 44))
+>A : Symbol(M.A, Decl(throwStatements.ts, 19, 10))
 
 throw aClassInModule;
->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3))
+>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3))
 
 var aFunctionInModule = M.F2;
->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3))
->M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5))
->M : Symbol(M, Decl(throwStatements.ts, 16, 44))
->F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5))
+>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3))
+>M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5))
+>M : Symbol(M, Decl(throwStatements.ts, 17, 44))
+>F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5))
 
 throw aFunctionInModule;
->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3))
+>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3))
 
 // no initializer or annotation, so this is an 'any'
 var x;
->x : Symbol(x, Decl(throwStatements.ts, 65, 3))
+>x : Symbol(x, Decl(throwStatements.ts, 66, 3))
 
 throw x;
->x : Symbol(x, Decl(throwStatements.ts, 65, 3))
+>x : Symbol(x, Decl(throwStatements.ts, 66, 3))
 
 // literals
 throw 0.0;
@@ -190,13 +191,13 @@ throw undefined;
 throw 'a string';
 throw function () { return 'a string' };
 throw <T>(x:T) => 42;
->T : Symbol(T, Decl(throwStatements.ts, 75, 7))
->x : Symbol(x, Decl(throwStatements.ts, 75, 10))
->T : Symbol(T, Decl(throwStatements.ts, 75, 7))
+>T : Symbol(T, Decl(throwStatements.ts, 76, 7))
+>x : Symbol(x, Decl(throwStatements.ts, 76, 10))
+>T : Symbol(T, Decl(throwStatements.ts, 76, 7))
 
 throw { x: 12, y: 13 };
->x : Symbol(x, Decl(throwStatements.ts, 76, 7))
->y : Symbol(y, Decl(throwStatements.ts, 76, 14))
+>x : Symbol(x, Decl(throwStatements.ts, 77, 7))
+>y : Symbol(y, Decl(throwStatements.ts, 77, 14))
 
 throw [];
 throw ['a', ['b']];
@@ -205,11 +206,11 @@ throw new Date();
 >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw new C();
->C : Symbol(C, Decl(throwStatements.ts, 4, 1))
+>C : Symbol(C, Decl(throwStatements.ts, 5, 1))
 
 throw new Object();
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
 throw new D<number>();
->D : Symbol(D, Decl(throwStatements.ts, 8, 1))
+>D : Symbol(D, Decl(throwStatements.ts, 9, 1))
 
diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types
index 3d365a1b65a..5023513ee53 100644
--- a/tests/baselines/reference/throwStatements.types
+++ b/tests/baselines/reference/throwStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/throwStatements/throwStatements.ts ===
+
 // all legal
 
 interface I {
diff --git a/tests/baselines/reference/throwWithoutNewLine2.errors.txt b/tests/baselines/reference/throwWithoutNewLine2.errors.txt
index 6930d240e7b..83f4e4cc246 100644
--- a/tests/baselines/reference/throwWithoutNewLine2.errors.txt
+++ b/tests/baselines/reference/throwWithoutNewLine2.errors.txt
@@ -1,11 +1,14 @@
 tests/cases/compiler/throwWithoutNewLine2.ts(1,6): error TS1142: Line break not permitted here.
 tests/cases/compiler/throwWithoutNewLine2.ts(2,1): error TS2304: Cannot find name 'a'.
+tests/cases/compiler/throwWithoutNewLine2.ts(2,1): error TS7027: Unreachable code detected.
 
 
-==== tests/cases/compiler/throwWithoutNewLine2.ts (2 errors) ====
+==== tests/cases/compiler/throwWithoutNewLine2.ts (3 errors) ====
     throw
          
 !!! error TS1142: Line break not permitted here.
     a;
     ~
-!!! error TS2304: Cannot find name 'a'.
\ No newline at end of file
+!!! error TS2304: Cannot find name 'a'.
+    ~
+!!! error TS7027: Unreachable code detected.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt
index a1427dc2526..92d9d21f0cc 100644
--- a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt
+++ b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt
@@ -9,6 +9,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(38,51)
   Property 'propA' is missing in type 'B'.
 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(42,56): error TS2322: Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(46,56): error TS2322: Type 'T[]' is not assignable to type 'string'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(50,1): error TS7027: Unreachable code detected.
 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(60,7): error TS2339: Property 'propB' does not exist on type 'A'.
 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(65,7): error TS2339: Property 'propB' does not exist on type 'A'.
 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(70,7): error TS2339: Property 'propB' does not exist on type 'A'.
@@ -39,7 +40,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(133,34
 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(137,39): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern.
 
 
-==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (32 errors) ====
+==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (33 errors) ====
     
     class A {
         propA: number;
@@ -111,6 +112,8 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(137,39
     }
     
     let a: A;
+    ~~~
+!!! error TS7027: Unreachable code detected.
     let b: B;
     
     declare function isB(p1): p1 is B;
diff --git a/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt
index 6112b61ceb6..0139c96b3f9 100644
--- a/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt
+++ b/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt
@@ -1,9 +1,12 @@
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(46,32): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(47,32): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'.
 tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(48,32): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(68,1): error TS7028: Unused label.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(69,1): error TS7028: Unused label.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(70,1): error TS7028: Unused label.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts (3 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts (6 errors) ====
     // typeof  operator on any type
     
     var ANY: any;
@@ -78,8 +81,14 @@ tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperator
     var x: any[];
     var r: () => any;
     z: typeof ANY;
+    ~
+!!! error TS7028: Unused label.
     x: typeof ANY2;
+    ~
+!!! error TS7028: Unused label.
     r: typeof foo;
+    ~
+!!! error TS7028: Unused label.
     z: typeof objA.a;
     z: typeof A.foo;
     z: typeof M.n;
diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.js b/tests/baselines/reference/typeofOperatorWithBooleanType.js
index c0538b78b14..b9db33b11a4 100644
--- a/tests/baselines/reference/typeofOperatorWithBooleanType.js
+++ b/tests/baselines/reference/typeofOperatorWithBooleanType.js
@@ -1,4 +1,5 @@
 //// [typeofOperatorWithBooleanType.ts]
+
 // typeof  operator on boolean type
 var BOOLEAN: boolean;
 
diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
index 39276e61625..0167a14ae03 100644
--- a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols
@@ -1,130 +1,131 @@
 === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts ===
+
 // typeof  operator on boolean type
 var BOOLEAN: boolean;
->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3))
+>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3))
 
 function foo(): boolean { return true; }
->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21))
+>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21))
 
 class A {
->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40))
+>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40))
 
     public a: boolean;
->a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
+>a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
 
     static foo() { return false; }
->foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22))
+>foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22))
 }
 module M {
->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1))
+>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1))
 
     export var n: boolean;
->n : Symbol(n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
+>n : Symbol(n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
 }
 
 var objA = new A();
->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3))
->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40))
+>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3))
+>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40))
 
 // boolean type var
 var ResultIsString1 = typeof BOOLEAN;
->ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithBooleanType.ts, 16, 3))
->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3))
+>ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithBooleanType.ts, 17, 3))
+>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3))
 
 // boolean type literal
 var ResultIsString2 = typeof true;
->ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithBooleanType.ts, 19, 3))
+>ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithBooleanType.ts, 20, 3))
 
 var ResultIsString3 = typeof { x: true, y: false };
->ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithBooleanType.ts, 20, 3))
->x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 20, 30))
->y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 20, 39))
+>ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithBooleanType.ts, 21, 3))
+>x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 21, 30))
+>y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 21, 39))
 
 // boolean type expressions
 var ResultIsString4 = typeof objA.a;
->ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithBooleanType.ts, 23, 3))
->objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3))
->a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
+>ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithBooleanType.ts, 24, 3))
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
 
 var ResultIsString5 = typeof M.n;
->ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithBooleanType.ts, 24, 3))
->M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1))
->n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
+>ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithBooleanType.ts, 25, 3))
+>M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
 
 var ResultIsString6 = typeof foo();
->ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithBooleanType.ts, 25, 3))
->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21))
+>ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithBooleanType.ts, 26, 3))
+>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21))
 
 var ResultIsString7 = typeof A.foo();
->ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithBooleanType.ts, 26, 3))
->A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22))
->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40))
->foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22))
+>ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithBooleanType.ts, 27, 3))
+>A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22))
+>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40))
+>foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22))
 
 // multiple typeof  operator
 var ResultIsString8 = typeof typeof BOOLEAN;
->ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithBooleanType.ts, 29, 3))
->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3))
+>ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithBooleanType.ts, 30, 3))
+>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3))
 
 // miss assignment operators
 typeof true;
 typeof BOOLEAN;
->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3))
+>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3))
 
 typeof foo();
->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21))
+>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21))
 
 typeof true, false;
 typeof objA.a;
->objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3))
->a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
 
 typeof M.n;
->M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1))
->n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
+>M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
 
 // use typeof in type query
 var z: boolean;
->z : Symbol(z, Decl(typeofOperatorWithBooleanType.ts, 40, 3))
+>z : Symbol(z, Decl(typeofOperatorWithBooleanType.ts, 41, 3))
 
 var x: boolean[];
->x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 41, 3))
+>x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 42, 3))
 
 var r: () => boolean;
->r : Symbol(r, Decl(typeofOperatorWithBooleanType.ts, 42, 3))
+>r : Symbol(r, Decl(typeofOperatorWithBooleanType.ts, 43, 3))
 
 z: typeof BOOLEAN;
->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3))
+>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3))
 
 r: typeof foo;
->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21))
+>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21))
 
 var y = { a: true, b: false};
->y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 45, 3))
->a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9))
->b : Symbol(b, Decl(typeofOperatorWithBooleanType.ts, 45, 18))
+>y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 46, 3))
+>a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 46, 9))
+>b : Symbol(b, Decl(typeofOperatorWithBooleanType.ts, 46, 18))
 
 z: typeof y.a;
->y.a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9))
->y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 45, 3))
->a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9))
+>y.a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 46, 9))
+>y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 46, 3))
+>a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 46, 9))
 
 z: typeof objA.a;
->objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3))
->a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9))
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9))
 
 z: typeof A.foo;
->A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22))
->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40))
->foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22))
+>A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22))
+>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40))
+>foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22))
 
 z: typeof M.n;
->M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1))
->n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14))
+>M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14))
 
diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.types b/tests/baselines/reference/typeofOperatorWithBooleanType.types
index 06cd7466a18..043307cfb00 100644
--- a/tests/baselines/reference/typeofOperatorWithBooleanType.types
+++ b/tests/baselines/reference/typeofOperatorWithBooleanType.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts ===
+
 // typeof  operator on boolean type
 var BOOLEAN: boolean;
 >BOOLEAN : boolean
diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.js b/tests/baselines/reference/typeofOperatorWithEnumType.js
index 2e2963b0955..2ce32668186 100644
--- a/tests/baselines/reference/typeofOperatorWithEnumType.js
+++ b/tests/baselines/reference/typeofOperatorWithEnumType.js
@@ -1,4 +1,5 @@
 //// [typeofOperatorWithEnumType.ts]
+
 // typeof  operator on enum type
 
 enum ENUM { };
diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.symbols b/tests/baselines/reference/typeofOperatorWithEnumType.symbols
index 3ae150ece03..a8e3d6d351f 100644
--- a/tests/baselines/reference/typeofOperatorWithEnumType.symbols
+++ b/tests/baselines/reference/typeofOperatorWithEnumType.symbols
@@ -1,69 +1,70 @@
 === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts ===
+
 // typeof  operator on enum type
 
 enum ENUM { };
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
 
 enum ENUM1 { A, B, "" };
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
->A : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 3, 12))
->B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
+>A : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 4, 12))
+>B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15))
 
 // enum type var
 var ResultIsString1 = typeof ENUM;
->ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithEnumType.ts, 6, 3))
+>ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithEnumType.ts, 7, 3))
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
 
 var ResultIsString2 = typeof ENUM1;
->ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithEnumType.ts, 7, 3))
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
+>ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithEnumType.ts, 8, 3))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
 
 // enum type expressions
 var ResultIsString3 = typeof ENUM1["A"];
->ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithEnumType.ts, 10, 3))
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
->"A" : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 3, 12))
+>ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithEnumType.ts, 11, 3))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
+>"A" : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 4, 12))
 
 var ResultIsString4 = typeof (ENUM[0] + ENUM1["B"]);
->ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithEnumType.ts, 11, 3))
+>ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithEnumType.ts, 12, 3))
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
->"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
+>"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15))
 
 // multiple typeof  operators
 var ResultIsString5 = typeof typeof ENUM;
->ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithEnumType.ts, 14, 3))
+>ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithEnumType.ts, 15, 3))
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
 
 var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1.B);
->ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithEnumType.ts, 15, 3))
+>ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithEnumType.ts, 16, 3))
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
->ENUM1.B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15))
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
->B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15))
+>ENUM1.B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
+>B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15))
 
 // miss assignment operators
 typeof ENUM;
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
 
 typeof ENUM1;
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
 
 typeof ENUM1["B"];
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
->"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
+>"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15))
 
 typeof ENUM, ENUM1;
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
 
 // use typeof in type query
 enum z { };
->z : Symbol(z, Decl(typeofOperatorWithEnumType.ts, 21, 19))
+>z : Symbol(z, Decl(typeofOperatorWithEnumType.ts, 22, 19))
 
 z: typeof ENUM;
 >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0))
 
 z: typeof ENUM1;
->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14))
+>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14))
 
diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.types b/tests/baselines/reference/typeofOperatorWithEnumType.types
index 82bf699a22f..f9224811393 100644
--- a/tests/baselines/reference/typeofOperatorWithEnumType.types
+++ b/tests/baselines/reference/typeofOperatorWithEnumType.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts ===
+
 // typeof  operator on enum type
 
 enum ENUM { };
diff --git a/tests/baselines/reference/typeofOperatorWithStringType.errors.txt b/tests/baselines/reference/typeofOperatorWithStringType.errors.txt
new file mode 100644
index 00000000000..37b2cafab37
--- /dev/null
+++ b/tests/baselines/reference/typeofOperatorWithStringType.errors.txt
@@ -0,0 +1,69 @@
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts(50,1): error TS7028: Unused label.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts(51,1): error TS7028: Unused label.
+tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts(52,1): error TS7028: Unused label.
+
+
+==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts (3 errors) ====
+    // typeof  operator on string type
+    var STRING: string;
+    var STRING1: string[] = ["", "abc"];
+    
+    function foo(): string { return "abc"; }
+    
+    class A {
+        public a: string;
+        static foo() { return ""; }
+    }
+    module M {
+        export var n: string;
+    }
+    
+    var objA = new A();
+    
+    // string type var
+    var ResultIsString1 = typeof STRING;
+    var ResultIsString2 = typeof STRING1;
+    
+    // string type literal
+    var ResultIsString3 = typeof "";
+    var ResultIsString4 = typeof { x: "", y: "" };
+    var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } };
+    
+    // string type expressions
+    var ResultIsString6 = typeof objA.a;
+    var ResultIsString7 = typeof M.n;
+    var ResultIsString8 = typeof STRING1[0];
+    var ResultIsString9 = typeof foo();
+    var ResultIsString10 = typeof A.foo();
+    var ResultIsString11 = typeof (STRING + STRING);
+    var ResultIsString12 = typeof STRING.charAt(0);
+    
+    // multiple typeof  operators
+    var ResultIsString13 = typeof typeof STRING;
+    var ResultIsString14 = typeof typeof typeof (STRING + STRING);
+    
+    // miss assignment operators
+    typeof "";
+    typeof STRING;
+    typeof STRING1;
+    typeof foo();
+    typeof objA.a, M.n;
+    
+    // use typeof in type query
+    var z: string;
+    var x: string[];
+    var r: () => string;
+    z: typeof STRING;
+    ~
+!!! error TS7028: Unused label.
+    x: typeof STRING1;
+    ~
+!!! error TS7028: Unused label.
+    r: typeof foo;
+    ~
+!!! error TS7028: Unused label.
+    var y = { a: "", b: "" };
+    z: typeof y.a;
+    z: typeof objA.a;
+    z: typeof A.foo;
+    z: typeof M.n;
\ No newline at end of file
diff --git a/tests/baselines/reference/typeofOperatorWithStringType.symbols b/tests/baselines/reference/typeofOperatorWithStringType.symbols
deleted file mode 100644
index 090e0958e60..00000000000
--- a/tests/baselines/reference/typeofOperatorWithStringType.symbols
+++ /dev/null
@@ -1,167 +0,0 @@
-=== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts ===
-// typeof  operator on string type
-var STRING: string;
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-var STRING1: string[] = ["", "abc"];
->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3))
-
-function foo(): string { return "abc"; }
->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36))
-
-class A {
->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40))
-
-    public a: string;
->a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 6, 9))
-
-    static foo() { return ""; }
->foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21))
-}
-module M {
->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1))
-
-    export var n: string;
->n : Symbol(n, Decl(typeofOperatorWithStringType.ts, 11, 14))
-}
-
-var objA = new A();
->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3))
->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40))
-
-// string type var
-var ResultIsString1 = typeof STRING;
->ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithStringType.ts, 17, 3))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-var ResultIsString2 = typeof STRING1;
->ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithStringType.ts, 18, 3))
->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3))
-
-// string type literal
-var ResultIsString3 = typeof "";
->ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithStringType.ts, 21, 3))
-
-var ResultIsString4 = typeof { x: "", y: "" };
->ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithStringType.ts, 22, 3))
->x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 22, 30))
->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 22, 37))
-
-var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } };
->ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithStringType.ts, 23, 3))
->x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 23, 30))
->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 23, 37))
->s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42))
->s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42))
-
-// string type expressions
-var ResultIsString6 = typeof objA.a;
->ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithStringType.ts, 26, 3))
->objA.a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9))
->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3))
->a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9))
-
-var ResultIsString7 = typeof M.n;
->ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithStringType.ts, 27, 3))
->M.n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14))
->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1))
->n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14))
-
-var ResultIsString8 = typeof STRING1[0];
->ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithStringType.ts, 28, 3))
->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3))
-
-var ResultIsString9 = typeof foo();
->ResultIsString9 : Symbol(ResultIsString9, Decl(typeofOperatorWithStringType.ts, 29, 3))
->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36))
-
-var ResultIsString10 = typeof A.foo();
->ResultIsString10 : Symbol(ResultIsString10, Decl(typeofOperatorWithStringType.ts, 30, 3))
->A.foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21))
->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40))
->foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21))
-
-var ResultIsString11 = typeof (STRING + STRING);
->ResultIsString11 : Symbol(ResultIsString11, Decl(typeofOperatorWithStringType.ts, 31, 3))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-var ResultIsString12 = typeof STRING.charAt(0);
->ResultIsString12 : Symbol(ResultIsString12, Decl(typeofOperatorWithStringType.ts, 32, 3))
->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
->charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
-
-// multiple typeof  operators
-var ResultIsString13 = typeof typeof STRING;
->ResultIsString13 : Symbol(ResultIsString13, Decl(typeofOperatorWithStringType.ts, 35, 3))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-var ResultIsString14 = typeof typeof typeof (STRING + STRING);
->ResultIsString14 : Symbol(ResultIsString14, Decl(typeofOperatorWithStringType.ts, 36, 3))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-// miss assignment operators
-typeof "";
-typeof STRING;
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-typeof STRING1;
->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3))
-
-typeof foo();
->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36))
-
-typeof objA.a, M.n;
->objA.a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9))
->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3))
->a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9))
->M.n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14))
->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1))
->n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14))
-
-// use typeof in type query
-var z: string;
->z : Symbol(z, Decl(typeofOperatorWithStringType.ts, 46, 3))
-
-var x: string[];
->x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 47, 3))
-
-var r: () => string;
->r : Symbol(r, Decl(typeofOperatorWithStringType.ts, 48, 3))
-
-z: typeof STRING;
->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3))
-
-x: typeof STRING1;
->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3))
-
-r: typeof foo;
->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36))
-
-var y = { a: "", b: "" };
->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 52, 3))
->a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9))
->b : Symbol(b, Decl(typeofOperatorWithStringType.ts, 52, 16))
-
-z: typeof y.a;
->y.a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9))
->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 52, 3))
->a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9))
-
-z: typeof objA.a;
->objA.a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9))
->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3))
->a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9))
-
-z: typeof A.foo;
->A.foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21))
->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40))
->foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21))
-
-z: typeof M.n;
->M.n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14))
->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1))
->n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14))
-
diff --git a/tests/baselines/reference/typeofOperatorWithStringType.types b/tests/baselines/reference/typeofOperatorWithStringType.types
deleted file mode 100644
index 3ae657a9951..00000000000
--- a/tests/baselines/reference/typeofOperatorWithStringType.types
+++ /dev/null
@@ -1,233 +0,0 @@
-=== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts ===
-// typeof  operator on string type
-var STRING: string;
->STRING : string
-
-var STRING1: string[] = ["", "abc"];
->STRING1 : string[]
->["", "abc"] : string[]
->"" : string
->"abc" : string
-
-function foo(): string { return "abc"; }
->foo : () => string
->"abc" : string
-
-class A {
->A : A
-
-    public a: string;
->a : string
-
-    static foo() { return ""; }
->foo : () => string
->"" : string
-}
-module M {
->M : typeof M
-
-    export var n: string;
->n : string
-}
-
-var objA = new A();
->objA : A
->new A() : A
->A : typeof A
-
-// string type var
-var ResultIsString1 = typeof STRING;
->ResultIsString1 : string
->typeof STRING : string
->STRING : string
-
-var ResultIsString2 = typeof STRING1;
->ResultIsString2 : string
->typeof STRING1 : string
->STRING1 : string[]
-
-// string type literal
-var ResultIsString3 = typeof "";
->ResultIsString3 : string
->typeof "" : string
->"" : string
-
-var ResultIsString4 = typeof { x: "", y: "" };
->ResultIsString4 : string
->typeof { x: "", y: "" } : string
->{ x: "", y: "" } : { x: string; y: string; }
->x : string
->"" : string
->y : string
->"" : string
-
-var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } };
->ResultIsString5 : string
->typeof { x: "", y: (s: string) => { return s; } } : string
->{ x: "", y: (s: string) => { return s; } } : { x: string; y: (s: string) => string; }
->x : string
->"" : string
->y : (s: string) => string
->(s: string) => { return s; } : (s: string) => string
->s : string
->s : string
-
-// string type expressions
-var ResultIsString6 = typeof objA.a;
->ResultIsString6 : string
->typeof objA.a : string
->objA.a : string
->objA : A
->a : string
-
-var ResultIsString7 = typeof M.n;
->ResultIsString7 : string
->typeof M.n : string
->M.n : string
->M : typeof M
->n : string
-
-var ResultIsString8 = typeof STRING1[0];
->ResultIsString8 : string
->typeof STRING1[0] : string
->STRING1[0] : string
->STRING1 : string[]
->0 : number
-
-var ResultIsString9 = typeof foo();
->ResultIsString9 : string
->typeof foo() : string
->foo() : string
->foo : () => string
-
-var ResultIsString10 = typeof A.foo();
->ResultIsString10 : string
->typeof A.foo() : string
->A.foo() : string
->A.foo : () => string
->A : typeof A
->foo : () => string
-
-var ResultIsString11 = typeof (STRING + STRING);
->ResultIsString11 : string
->typeof (STRING + STRING) : string
->(STRING + STRING) : string
->STRING + STRING : string
->STRING : string
->STRING : string
-
-var ResultIsString12 = typeof STRING.charAt(0);
->ResultIsString12 : string
->typeof STRING.charAt(0) : string
->STRING.charAt(0) : string
->STRING.charAt : (pos: number) => string
->STRING : string
->charAt : (pos: number) => string
->0 : number
-
-// multiple typeof  operators
-var ResultIsString13 = typeof typeof STRING;
->ResultIsString13 : string
->typeof typeof STRING : string
->typeof STRING : string
->STRING : string
-
-var ResultIsString14 = typeof typeof typeof (STRING + STRING);
->ResultIsString14 : string
->typeof typeof typeof (STRING + STRING) : string
->typeof typeof (STRING + STRING) : string
->typeof (STRING + STRING) : string
->(STRING + STRING) : string
->STRING + STRING : string
->STRING : string
->STRING : string
-
-// miss assignment operators
-typeof "";
->typeof "" : string
->"" : string
-
-typeof STRING;
->typeof STRING : string
->STRING : string
-
-typeof STRING1;
->typeof STRING1 : string
->STRING1 : string[]
-
-typeof foo();
->typeof foo() : string
->foo() : string
->foo : () => string
-
-typeof objA.a, M.n;
->typeof objA.a, M.n : string
->typeof objA.a : string
->objA.a : string
->objA : A
->a : string
->M.n : string
->M : typeof M
->n : string
-
-// use typeof in type query
-var z: string;
->z : string
-
-var x: string[];
->x : string[]
-
-var r: () => string;
->r : () => string
-
-z: typeof STRING;
->z : any
->typeof STRING : string
->STRING : string
-
-x: typeof STRING1;
->x : any
->typeof STRING1 : string
->STRING1 : string[]
-
-r: typeof foo;
->r : any
->typeof foo : string
->foo : () => string
-
-var y = { a: "", b: "" };
->y : { a: string; b: string; }
->{ a: "", b: "" } : { a: string; b: string; }
->a : string
->"" : string
->b : string
->"" : string
-
-z: typeof y.a;
->z : any
->typeof y.a : string
->y.a : string
->y : { a: string; b: string; }
->a : string
-
-z: typeof objA.a;
->z : any
->typeof objA.a : string
->objA.a : string
->objA : A
->a : string
-
-z: typeof A.foo;
->z : any
->typeof A.foo : string
->A.foo : () => string
->A : typeof A
->foo : () => string
-
-z: typeof M.n;
->z : any
->typeof M.n : string
->M.n : string
->M : typeof M
->n : string
-
diff --git a/tests/baselines/reference/undeclaredVarEmit.errors.txt b/tests/baselines/reference/undeclaredVarEmit.errors.txt
index af6298b61d2..a95323aa362 100644
--- a/tests/baselines/reference/undeclaredVarEmit.errors.txt
+++ b/tests/baselines/reference/undeclaredVarEmit.errors.txt
@@ -1,7 +1,10 @@
+tests/cases/compiler/undeclaredVarEmit.ts(1,1): error TS7028: Unused label.
 tests/cases/compiler/undeclaredVarEmit.ts(1,4): error TS2304: Cannot find name 'number'.
 
 
-==== tests/cases/compiler/undeclaredVarEmit.ts (1 errors) ====
+==== tests/cases/compiler/undeclaredVarEmit.ts (2 errors) ====
     f: number;
+    ~
+!!! error TS7028: Unused label.
        ~~~~~~
 !!! error TS2304: Cannot find name 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/unionTypeCallSignatures4.errors.txt b/tests/baselines/reference/unionTypeCallSignatures4.errors.txt
new file mode 100644
index 00000000000..585906a6b5a
--- /dev/null
+++ b/tests/baselines/reference/unionTypeCallSignatures4.errors.txt
@@ -0,0 +1,41 @@
+tests/cases/conformance/types/union/unionTypeCallSignatures4.ts(10,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/union/unionTypeCallSignatures4.ts(20,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/union/unionTypeCallSignatures4.ts(23,1): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/union/unionTypeCallSignatures4.ts(25,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/union/unionTypeCallSignatures4.ts (4 errors) ====
+    type F1 = (a: string, b?: string) => void;
+    type F2 = (a: string, b?: string, c?: string) => void;
+    type F3 = (a: string, ...rest: string[]) => void;
+    type F4 = (a: string, b?: string, ...rest: string[]) => void;
+    type F5 = (a: string, b: string) => void;
+    
+    var f12: F1 | F2;
+    f12("a");
+    f12("a", "b");
+    f12("a", "b", "c");  // error
+    ~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    var f34: F3 | F4;
+    f34("a");
+    f34("a", "b");
+    f34("a", "b", "c");
+    
+    var f1234: F1 | F2 | F3 | F4;
+    f1234("a");
+    f1234("a", "b");
+    f1234("a", "b", "c");  // error
+    ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
+    var f12345: F1 | F2 | F3 | F4 | F5;
+    f12345("a");  // error
+    ~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    f12345("a", "b");
+    f12345("a", "b", "c");  // error
+    ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/unionTypeCallSignatures4.js b/tests/baselines/reference/unionTypeCallSignatures4.js
new file mode 100644
index 00000000000..be9a45b33c9
--- /dev/null
+++ b/tests/baselines/reference/unionTypeCallSignatures4.js
@@ -0,0 +1,45 @@
+//// [unionTypeCallSignatures4.ts]
+type F1 = (a: string, b?: string) => void;
+type F2 = (a: string, b?: string, c?: string) => void;
+type F3 = (a: string, ...rest: string[]) => void;
+type F4 = (a: string, b?: string, ...rest: string[]) => void;
+type F5 = (a: string, b: string) => void;
+
+var f12: F1 | F2;
+f12("a");
+f12("a", "b");
+f12("a", "b", "c");  // error
+
+var f34: F3 | F4;
+f34("a");
+f34("a", "b");
+f34("a", "b", "c");
+
+var f1234: F1 | F2 | F3 | F4;
+f1234("a");
+f1234("a", "b");
+f1234("a", "b", "c");  // error
+
+var f12345: F1 | F2 | F3 | F4 | F5;
+f12345("a");  // error
+f12345("a", "b");
+f12345("a", "b", "c");  // error
+
+
+//// [unionTypeCallSignatures4.js]
+var f12;
+f12("a");
+f12("a", "b");
+f12("a", "b", "c"); // error
+var f34;
+f34("a");
+f34("a", "b");
+f34("a", "b", "c");
+var f1234;
+f1234("a");
+f1234("a", "b");
+f1234("a", "b", "c"); // error
+var f12345;
+f12345("a"); // error
+f12345("a", "b");
+f12345("a", "b", "c"); // error
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.errors.txt b/tests/baselines/reference/validMultipleVariableDeclarations.errors.txt
new file mode 100644
index 00000000000..8f751e9efee
--- /dev/null
+++ b/tests/baselines/reference/validMultipleVariableDeclarations.errors.txt
@@ -0,0 +1,45 @@
+tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts(9,1): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts (1 errors) ====
+    // all expected to be valid
+    
+    var x: number;
+    var x = 2;
+    if (true) {
+        var x = 3;
+        for (var x = 0; ;) { }
+    }
+    var x = <number>undefined;
+    ~~~
+!!! error TS7027: Unreachable code detected.
+    
+    // new declaration space, making redeclaring x as a string valid
+    function declSpace() {
+        var x = 'this is a string';
+    }
+    
+    interface Point { x: number; y: number; }
+    
+    var p: Point;
+    var p = { x: 1, y: 2 };
+    var p: Point = { x: 0, y: undefined };
+    var p = { x: 1, y: <number>undefined };
+    var p: { x: number; y: number; } = { x: 1, y: 2 };
+    var p = <{ x: number; y: number; }>{ x: 0, y: undefined };
+    var p: typeof p;
+    
+    var fn = function (s: string) { return 42; }
+    var fn = (s: string) => 3;
+    var fn: (s: string) => number;
+    var fn: { (s: string): number };
+    var fn = <(s: string) => number> null;
+    var fn: typeof fn;
+    
+    var a: string[]; 
+    var a = ['a', 'b']
+    var a = <string[]>[];
+    var a: string[] = [];
+    var a = new Array<string>();
+    var a: typeof a;
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.symbols b/tests/baselines/reference/validMultipleVariableDeclarations.symbols
deleted file mode 100644
index 1c3a1feb75c..00000000000
--- a/tests/baselines/reference/validMultipleVariableDeclarations.symbols
+++ /dev/null
@@ -1,118 +0,0 @@
-=== tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts ===
-// all expected to be valid
-
-var x: number;
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3))
-
-var x = 2;
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3))
-
-if (true) {
-    var x = 3;
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3))
-
-    for (var x = 0; ;) { }
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3))
-}
-var x = <number>undefined;
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3))
->undefined : Symbol(undefined)
-
-// new declaration space, making redeclaring x as a string valid
-function declSpace() {
->declSpace : Symbol(declSpace, Decl(validMultipleVariableDeclarations.ts, 8, 26))
-
-    var x = 'this is a string';
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 12, 7))
-}
-
-interface Point { x: number; y: number; }
->Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 15, 17))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 15, 28))
-
-var p: Point;
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1))
-
-var p = { x: 1, y: 2 };
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 18, 9))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 18, 15))
-
-var p: Point = { x: 0, y: undefined };
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 19, 16))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 19, 22))
->undefined : Symbol(undefined)
-
-var p = { x: 1, y: <number>undefined };
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 20, 9))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 20, 15))
->undefined : Symbol(undefined)
-
-var p: { x: number; y: number; } = { x: 1, y: 2 };
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 8))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 19))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 36))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 42))
-
-var p = <{ x: number; y: number; }>{ x: 0, y: undefined };
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 10))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 21))
->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 36))
->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 42))
->undefined : Symbol(undefined)
-
-var p: typeof p;
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3))
-
-var fn = function (s: string) { return 42; }
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 25, 19))
-
-var fn = (s: string) => 3;
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 26, 10))
-
-var fn: (s: string) => number;
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 27, 9))
-
-var fn: { (s: string): number };
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 28, 11))
-
-var fn = <(s: string) => number> null;
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 29, 11))
-
-var fn: typeof fn;
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3))
-
-var a: string[]; 
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
-
-var a = ['a', 'b']
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
-
-var a = <string[]>[];
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
-
-var a: string[] = [];
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
-
-var a = new Array<string>();
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
-
-var a: typeof a;
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
->a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3))
-
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.types b/tests/baselines/reference/validMultipleVariableDeclarations.types
deleted file mode 100644
index 966128350b0..00000000000
--- a/tests/baselines/reference/validMultipleVariableDeclarations.types
+++ /dev/null
@@ -1,152 +0,0 @@
-=== tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts ===
-// all expected to be valid
-
-var x: number;
->x : number
-
-var x = 2;
->x : number
->2 : number
-
-if (true) {
->true : boolean
-
-    var x = 3;
->x : number
->3 : number
-
-    for (var x = 0; ;) { }
->x : number
->0 : number
-}
-var x = <number>undefined;
->x : number
-><number>undefined : number
->undefined : undefined
-
-// new declaration space, making redeclaring x as a string valid
-function declSpace() {
->declSpace : () => void
-
-    var x = 'this is a string';
->x : string
->'this is a string' : string
-}
-
-interface Point { x: number; y: number; }
->Point : Point
->x : number
->y : number
-
-var p: Point;
->p : Point
->Point : Point
-
-var p = { x: 1, y: 2 };
->p : Point
->{ x: 1, y: 2 } : { x: number; y: number; }
->x : number
->1 : number
->y : number
->2 : number
-
-var p: Point = { x: 0, y: undefined };
->p : Point
->Point : Point
->{ x: 0, y: undefined } : { x: number; y: undefined; }
->x : number
->0 : number
->y : undefined
->undefined : undefined
-
-var p = { x: 1, y: <number>undefined };
->p : Point
->{ x: 1, y: <number>undefined } : { x: number; y: number; }
->x : number
->1 : number
->y : number
-><number>undefined : number
->undefined : undefined
-
-var p: { x: number; y: number; } = { x: 1, y: 2 };
->p : Point
->x : number
->y : number
->{ x: 1, y: 2 } : { x: number; y: number; }
->x : number
->1 : number
->y : number
->2 : number
-
-var p = <{ x: number; y: number; }>{ x: 0, y: undefined };
->p : Point
-><{ x: number; y: number; }>{ x: 0, y: undefined } : { x: number; y: number; }
->x : number
->y : number
->{ x: 0, y: undefined } : { x: number; y: undefined; }
->x : number
->0 : number
->y : undefined
->undefined : undefined
-
-var p: typeof p;
->p : Point
->p : Point
-
-var fn = function (s: string) { return 42; }
->fn : (s: string) => number
->function (s: string) { return 42; } : (s: string) => number
->s : string
->42 : number
-
-var fn = (s: string) => 3;
->fn : (s: string) => number
->(s: string) => 3 : (s: string) => number
->s : string
->3 : number
-
-var fn: (s: string) => number;
->fn : (s: string) => number
->s : string
-
-var fn: { (s: string): number };
->fn : (s: string) => number
->s : string
-
-var fn = <(s: string) => number> null;
->fn : (s: string) => number
-><(s: string) => number> null : (s: string) => number
->s : string
->null : null
-
-var fn: typeof fn;
->fn : (s: string) => number
->fn : (s: string) => number
-
-var a: string[]; 
->a : string[]
-
-var a = ['a', 'b']
->a : string[]
->['a', 'b'] : string[]
->'a' : string
->'b' : string
-
-var a = <string[]>[];
->a : string[]
-><string[]>[] : string[]
->[] : undefined[]
-
-var a: string[] = [];
->a : string[]
->[] : undefined[]
-
-var a = new Array<string>();
->a : string[]
->new Array<string>() : string[]
->Array : ArrayConstructor
-
-var a: typeof a;
->a : string[]
->a : string[]
-
diff --git a/tests/baselines/reference/whileBreakStatements.js b/tests/baselines/reference/whileBreakStatements.js
index 818be39a242..15dffe3e582 100644
--- a/tests/baselines/reference/whileBreakStatements.js
+++ b/tests/baselines/reference/whileBreakStatements.js
@@ -1,4 +1,5 @@
 //// [whileBreakStatements.ts]
+
 while(true) {
     break;
 } 
diff --git a/tests/baselines/reference/whileBreakStatements.symbols b/tests/baselines/reference/whileBreakStatements.symbols
index 2ac7721621d..022fe9a12a8 100644
--- a/tests/baselines/reference/whileBreakStatements.symbols
+++ b/tests/baselines/reference/whileBreakStatements.symbols
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts ===
+
 while(true) {
     break;
 } 
@@ -38,7 +39,7 @@ while (true)
 EIGHT:
 while (true) {
     var fn = function () { }
->fn : Symbol(fn, Decl(whileBreakStatements.ts, 38, 7))
+>fn : Symbol(fn, Decl(whileBreakStatements.ts, 39, 7))
 
     break EIGHT;
 }
diff --git a/tests/baselines/reference/whileBreakStatements.types b/tests/baselines/reference/whileBreakStatements.types
index e7ca0a5322f..a31d1e9b40e 100644
--- a/tests/baselines/reference/whileBreakStatements.types
+++ b/tests/baselines/reference/whileBreakStatements.types
@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts ===
+
 while(true) {
 >true : boolean
 
diff --git a/tests/baselines/reference/whileContinueStatements.errors.txt b/tests/baselines/reference/whileContinueStatements.errors.txt
new file mode 100644
index 00000000000..c2009b02600
--- /dev/null
+++ b/tests/baselines/reference/whileContinueStatements.errors.txt
@@ -0,0 +1,59 @@
+tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts(5,1): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts (1 errors) ====
+    while(true) {
+        continue;
+    } 
+    
+    while (true) {
+    ~~~~~
+!!! error TS7027: Unreachable code detected.
+        if (true) {
+            continue;
+        }
+    }
+    
+    ONE:
+    
+    while (true) {
+        continue ONE;
+    }
+    
+    TWO:
+    THREE:
+    while (true) {
+        continue THREE;
+    }
+    
+    FOUR:
+    while (true) {
+        FIVE:
+        while (true) {
+            continue FOUR;
+        }
+    }
+    
+    while (true) {
+        SIX:
+        while (true)
+            continue SIX;
+    }
+    
+    SEVEN:
+    while (true)
+        while (true)
+            while (true)
+                continue SEVEN;
+    
+    EIGHT:
+    while (true) {
+        var fn = function () { }
+        continue EIGHT;
+    }
+    
+    NINE:
+    while (true) {
+        if (true) { continue NINE; }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/whileContinueStatements.symbols b/tests/baselines/reference/whileContinueStatements.symbols
deleted file mode 100644
index 67508556f70..00000000000
--- a/tests/baselines/reference/whileContinueStatements.symbols
+++ /dev/null
@@ -1,56 +0,0 @@
-=== tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts ===
-while(true) {
-    continue;
-} 
-
-while (true) {
-    if (true) {
-        continue;
-    }
-}
-
-ONE:
-
-while (true) {
-    continue ONE;
-}
-
-TWO:
-THREE:
-while (true) {
-    continue THREE;
-}
-
-FOUR:
-while (true) {
-    FIVE:
-    while (true) {
-        continue FOUR;
-    }
-}
-
-while (true) {
-    SIX:
-    while (true)
-        continue SIX;
-}
-
-SEVEN:
-while (true)
-    while (true)
-        while (true)
-            continue SEVEN;
-
-EIGHT:
-while (true) {
-    var fn = function () { }
->fn : Symbol(fn, Decl(whileContinueStatements.ts, 44, 7))
-
-    continue EIGHT;
-}
-
-NINE:
-while (true) {
-    if (true) { continue NINE; }
-}
-
diff --git a/tests/baselines/reference/whileContinueStatements.types b/tests/baselines/reference/whileContinueStatements.types
deleted file mode 100644
index 6bf371cde9e..00000000000
--- a/tests/baselines/reference/whileContinueStatements.types
+++ /dev/null
@@ -1,110 +0,0 @@
-=== tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts ===
-while(true) {
->true : boolean
-
-    continue;
-} 
-
-while (true) {
->true : boolean
-
-    if (true) {
->true : boolean
-
-        continue;
-    }
-}
-
-ONE:
->ONE : any
-
-while (true) {
->true : boolean
-
-    continue ONE;
->ONE : any
-}
-
-TWO:
->TWO : any
-
-THREE:
->THREE : any
-
-while (true) {
->true : boolean
-
-    continue THREE;
->THREE : any
-}
-
-FOUR:
->FOUR : any
-
-while (true) {
->true : boolean
-
-    FIVE:
->FIVE : any
-
-    while (true) {
->true : boolean
-
-        continue FOUR;
->FOUR : any
-    }
-}
-
-while (true) {
->true : boolean
-
-    SIX:
->SIX : any
-
-    while (true)
->true : boolean
-
-        continue SIX;
->SIX : any
-}
-
-SEVEN:
->SEVEN : any
-
-while (true)
->true : boolean
-
-    while (true)
->true : boolean
-
-        while (true)
->true : boolean
-
-            continue SEVEN;
->SEVEN : any
-
-EIGHT:
->EIGHT : any
-
-while (true) {
->true : boolean
-
-    var fn = function () { }
->fn : () => void
->function () { } : () => void
-
-    continue EIGHT;
->EIGHT : any
-}
-
-NINE:
->NINE : any
-
-while (true) {
->true : boolean
-
-    if (true) { continue NINE; }
->true : boolean
->NINE : any
-}
-
diff --git a/tests/cases/compiler/bestCommonTypeReturnStatement.ts b/tests/cases/compiler/bestCommonTypeReturnStatement.ts
index aff173664f6..cb481147f9b 100644
--- a/tests/cases/compiler/bestCommonTypeReturnStatement.ts
+++ b/tests/cases/compiler/bestCommonTypeReturnStatement.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface IPromise<T> {
     then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
 }
diff --git a/tests/cases/compiler/breakTarget3.ts b/tests/cases/compiler/breakTarget3.ts
index 9cef599692c..64a9357706f 100644
--- a/tests/cases/compiler/breakTarget3.ts
+++ b/tests/cases/compiler/breakTarget3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/breakTarget4.ts b/tests/cases/compiler/breakTarget4.ts
index 2c3eadca7db..3e00bca659b 100644
--- a/tests/cases/compiler/breakTarget4.ts
+++ b/tests/cases/compiler/breakTarget4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/breakTarget5.ts b/tests/cases/compiler/breakTarget5.ts
index a05ee1cf879..f0bceb5015f 100644
--- a/tests/cases/compiler/breakTarget5.ts
+++ b/tests/cases/compiler/breakTarget5.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/compiler/capturedLetConstInLoop9.ts b/tests/cases/compiler/capturedLetConstInLoop9.ts
index 8163a75c20b..4b67349690d 100644
--- a/tests/cases/compiler/capturedLetConstInLoop9.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop9.ts
@@ -74,9 +74,8 @@ function foo() {
                 break l0;
             }
             
-            return 100;
-            
             () => b
+            return 100;
         }
 
         
diff --git a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
index e11cf6d344a..25c696ff7e6 100644
--- a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
@@ -75,10 +75,8 @@ function foo() {
             if (b === 2) {
                 break l0;
             }
-            
-            return 100;
-            
             () => b
+            return 100;
         }
 
         
diff --git a/tests/cases/compiler/commentEmitAtEndOfFile1.ts b/tests/cases/compiler/commentEmitAtEndOfFile1.ts
index b1b863890d5..5713ef006e5 100644
--- a/tests/cases/compiler/commentEmitAtEndOfFile1.ts
+++ b/tests/cases/compiler/commentEmitAtEndOfFile1.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // test
 var f = ''
 // test #2
diff --git a/tests/cases/compiler/commentsAtEndOfFile1.ts b/tests/cases/compiler/commentsAtEndOfFile1.ts
index 8e37b2361a5..04c90b3433a 100644
--- a/tests/cases/compiler/commentsAtEndOfFile1.ts
+++ b/tests/cases/compiler/commentsAtEndOfFile1.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 Input:
 ;
 //Testing two
diff --git a/tests/cases/compiler/conditionalExpressions2.ts b/tests/cases/compiler/conditionalExpressions2.ts
index 6f2f097f6de..ece002d7778 100644
--- a/tests/cases/compiler/conditionalExpressions2.ts
+++ b/tests/cases/compiler/conditionalExpressions2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 var a = false ? 1 : null;
 var b = false ? undefined : 0;
 var c = false ? 1 : 0;
diff --git a/tests/cases/compiler/constDeclarations-invalidContexts.ts b/tests/cases/compiler/constDeclarations-invalidContexts.ts
index b5093180990..6d21ee31ec2 100644
--- a/tests/cases/compiler/constDeclarations-invalidContexts.ts
+++ b/tests/cases/compiler/constDeclarations-invalidContexts.ts
@@ -1,3 +1,4 @@
+// @allowUnreachableCode: true
 // @target: ES6
 
 // Errors, const must be defined inside a block
diff --git a/tests/cases/compiler/constDeclarations-validContexts.ts b/tests/cases/compiler/constDeclarations-validContexts.ts
index ffde8e45d6f..63af6d16959 100644
--- a/tests/cases/compiler/constDeclarations-validContexts.ts
+++ b/tests/cases/compiler/constDeclarations-validContexts.ts
@@ -1,3 +1,4 @@
+// @allowUnreachableCode: true
 // @target: ES6
 
 
diff --git a/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts b/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts
index a93628e5494..63e0fc30141 100644
--- a/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts
+++ b/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 declare module "fs" {
     export class File {
         constructor(filename: string);
diff --git a/tests/cases/compiler/continueNotInIterationStatement4.ts b/tests/cases/compiler/continueNotInIterationStatement4.ts
index 5996eb4323a..218cb151df3 100644
--- a/tests/cases/compiler/continueNotInIterationStatement4.ts
+++ b/tests/cases/compiler/continueNotInIterationStatement4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 TWO:
 while (true){
   var x = () => {
diff --git a/tests/cases/compiler/continueTarget3.ts b/tests/cases/compiler/continueTarget3.ts
index 26bea241a7a..a7b47ff071b 100644
--- a/tests/cases/compiler/continueTarget3.ts
+++ b/tests/cases/compiler/continueTarget3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/continueTarget4.ts b/tests/cases/compiler/continueTarget4.ts
index e00c222aa9c..5ba2bd69b11 100644
--- a/tests/cases/compiler/continueTarget4.ts
+++ b/tests/cases/compiler/continueTarget4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/compiler/continueTarget5.ts b/tests/cases/compiler/continueTarget5.ts
index dd3a806ab2d..5f3d068282b 100644
--- a/tests/cases/compiler/continueTarget5.ts
+++ b/tests/cases/compiler/continueTarget5.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/compiler/declarationEmitDetachedComment1.ts b/tests/cases/compiler/declarationEmitDetachedComment1.ts
new file mode 100644
index 00000000000..8d49482f3cc
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitDetachedComment1.ts
@@ -0,0 +1,34 @@
+// @target: es5
+// @module: commonjs
+// @declaration: true
+// @removeComments: false
+
+// @filename: test1.ts
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+
+}
+
+// @filename: test2.ts
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+
+}
+
+// @filename: test3.ts
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+
+}
diff --git a/tests/cases/compiler/declarationEmitDetachedComment2.ts b/tests/cases/compiler/declarationEmitDetachedComment2.ts
new file mode 100644
index 00000000000..1eed803c625
--- /dev/null
+++ b/tests/cases/compiler/declarationEmitDetachedComment2.ts
@@ -0,0 +1,34 @@
+// @target: es5
+// @module: commonjs
+// @declaration: true
+// @removeComments: true
+
+// @filename: test1.ts
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+
+}
+
+// @filename: test2.ts
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+
+}
+
+// @filename: test3.ts
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+
+}
diff --git a/tests/cases/compiler/downlevelLetConst16.ts b/tests/cases/compiler/downlevelLetConst16.ts
index 30a27ba61f4..b30f26b4b82 100644
--- a/tests/cases/compiler/downlevelLetConst16.ts
+++ b/tests/cases/compiler/downlevelLetConst16.ts
@@ -1,4 +1,6 @@
 // @target:es5
+// @allowUnreachableCode: true
+
 'use strict'
 
 declare function use(a: any);
diff --git a/tests/cases/compiler/downlevelLetConst17.ts b/tests/cases/compiler/downlevelLetConst17.ts
index b581281f679..7cea2031ac5 100644
--- a/tests/cases/compiler/downlevelLetConst17.ts
+++ b/tests/cases/compiler/downlevelLetConst17.ts
@@ -1,4 +1,5 @@
 // @target:es5
+// @allowUnreachableCode: true
 'use strict'
 
 declare function use(a: any);
diff --git a/tests/cases/compiler/downlevelLetConst18.ts b/tests/cases/compiler/downlevelLetConst18.ts
index 59f2ee7a46e..61cb2f46cc9 100644
--- a/tests/cases/compiler/downlevelLetConst18.ts
+++ b/tests/cases/compiler/downlevelLetConst18.ts
@@ -1,4 +1,6 @@
 // @target:es5
+// @allowUnreachableCode: true
+
 'use strict'
 
 for (let x; ;) {
@@ -6,7 +8,7 @@ for (let x; ;) {
 }
 
 for (let x; ;) {
-    function foo() { x };
+    function foo1() { x };
 }
 
 for (let x; ;) {
diff --git a/tests/cases/compiler/duplicateLabel1.ts b/tests/cases/compiler/duplicateLabel1.ts
index c588e7b8183..ff248c64548 100644
--- a/tests/cases/compiler/duplicateLabel1.ts
+++ b/tests/cases/compiler/duplicateLabel1.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 target:
 while (true) {
diff --git a/tests/cases/compiler/duplicateLabel2.ts b/tests/cases/compiler/duplicateLabel2.ts
index bdb0396a246..5ebf273c118 100644
--- a/tests/cases/compiler/duplicateLabel2.ts
+++ b/tests/cases/compiler/duplicateLabel2.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   target:
diff --git a/tests/cases/compiler/duplicateLabel3.ts b/tests/cases/compiler/duplicateLabel3.ts
index d4db9399ed2..d6add980447 100644
--- a/tests/cases/compiler/duplicateLabel3.ts
+++ b/tests/cases/compiler/duplicateLabel3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/compiler/duplicateLabel4.ts b/tests/cases/compiler/duplicateLabel4.ts
index 2c62180a2ab..bf7ea5c22c6 100644
--- a/tests/cases/compiler/duplicateLabel4.ts
+++ b/tests/cases/compiler/duplicateLabel4.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 target:
 while (true) {
 }
diff --git a/tests/cases/compiler/duplicateLocalVariable1.ts b/tests/cases/compiler/duplicateLocalVariable1.ts
index fc20a19c2d9..f6288cfc6ae 100644
--- a/tests/cases/compiler/duplicateLocalVariable1.ts
+++ b/tests/cases/compiler/duplicateLocalVariable1.ts
@@ -1,4 +1,6 @@
-//@module: commonjs
+
+// @allowUnreachableCode: true
+/ /@module: commonjs
 
 //import FileManager = require('filemanager');
 //import App = require('app');
diff --git a/tests/cases/compiler/duplicateVariablesByScope.ts b/tests/cases/compiler/duplicateVariablesByScope.ts
index 481c1bb950e..dc811130d4f 100644
--- a/tests/cases/compiler/duplicateVariablesByScope.ts
+++ b/tests/cases/compiler/duplicateVariablesByScope.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // duplicate local variables are only reported at global scope
 
 module M {
diff --git a/tests/cases/compiler/es6ClassSuperCodegenBug.ts b/tests/cases/compiler/es6ClassSuperCodegenBug.ts
index 7ab8344c815..2e3f306d5d6 100644
--- a/tests/cases/compiler/es6ClassSuperCodegenBug.ts
+++ b/tests/cases/compiler/es6ClassSuperCodegenBug.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class A {
 	constructor(str1:string, str2:string) {}
 }
diff --git a/tests/cases/compiler/escapedIdentifiers.ts b/tests/cases/compiler/escapedIdentifiers.ts
index 795aeca2481..c58c59d9b42 100644
--- a/tests/cases/compiler/escapedIdentifiers.ts
+++ b/tests/cases/compiler/escapedIdentifiers.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 /*
     0 .. \u0030
     9 .. \u0039
diff --git a/tests/cases/compiler/for.ts b/tests/cases/compiler/for.ts
index e27dab7dbd2..636c7e4a5fc 100644
--- a/tests/cases/compiler/for.ts
+++ b/tests/cases/compiler/for.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 for (var i = 0; i < 10; i++) { // ok
     var x1 = i;
 }
diff --git a/tests/cases/compiler/functionOverloads12.ts b/tests/cases/compiler/functionOverloads12.ts
index 3e8a9882d08..48a8af06cc5 100644
--- a/tests/cases/compiler/functionOverloads12.ts
+++ b/tests/cases/compiler/functionOverloads12.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function foo():string;
 function foo():number;
 function foo():any { if (true) return ""; else return 0;}
diff --git a/tests/cases/compiler/functionReturn.ts b/tests/cases/compiler/functionReturn.ts
index 8ea0cb8f5a1..897480c64d6 100644
--- a/tests/cases/compiler/functionReturn.ts
+++ b/tests/cases/compiler/functionReturn.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function f0(): void { }
 function f1() {
     var n: any = f0();
diff --git a/tests/cases/compiler/functionWithNoBestCommonType1.ts b/tests/cases/compiler/functionWithNoBestCommonType1.ts
index 11628812925..2d7a1191770 100644
--- a/tests/cases/compiler/functionWithNoBestCommonType1.ts
+++ b/tests/cases/compiler/functionWithNoBestCommonType1.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function foo() {
     return true;
     return bar();
diff --git a/tests/cases/compiler/functionWithNoBestCommonType2.ts b/tests/cases/compiler/functionWithNoBestCommonType2.ts
index 974ccdfe035..6bc3878d834 100644
--- a/tests/cases/compiler/functionWithNoBestCommonType2.ts
+++ b/tests/cases/compiler/functionWithNoBestCommonType2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 var v = function () {
    return true;
    return bar();
diff --git a/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts b/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts
index 81259fd7c0c..fde615af41d 100644
--- a/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts
+++ b/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // @target: es5
 
 function f1(): string {
diff --git a/tests/cases/compiler/ifElseWithStatements1.ts b/tests/cases/compiler/ifElseWithStatements1.ts
index a7f337068cb..5ed7f7dd7a3 100644
--- a/tests/cases/compiler/ifElseWithStatements1.ts
+++ b/tests/cases/compiler/ifElseWithStatements1.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 if (true)
     f();
 else
diff --git a/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts b/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts
index d150fb1930a..6465e7f1200 100644
--- a/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts
+++ b/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function foo() {
     if (true) {
         return 42;
diff --git a/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts b/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts
index 2620e7d88d4..e325ae4582a 100644
--- a/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts
+++ b/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class a {
     static get x(): () => string {
         return null;;
diff --git a/tests/cases/compiler/letAndVarRedeclaration.ts b/tests/cases/compiler/letAndVarRedeclaration.ts
index 1f901ded520..aaf2ce1a68c 100644
--- a/tests/cases/compiler/letAndVarRedeclaration.ts
+++ b/tests/cases/compiler/letAndVarRedeclaration.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // @target: es6
 
 let e0
diff --git a/tests/cases/compiler/letDeclarations-invalidContexts.ts b/tests/cases/compiler/letDeclarations-invalidContexts.ts
index 4d165ba2cda..cde6c2006bb 100644
--- a/tests/cases/compiler/letDeclarations-invalidContexts.ts
+++ b/tests/cases/compiler/letDeclarations-invalidContexts.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // @target: ES6
 
 // Errors, let must be defined inside a block
diff --git a/tests/cases/compiler/letDeclarations-scopes.ts b/tests/cases/compiler/letDeclarations-scopes.ts
index 93f4ce5b4ed..b050a5e9bd0 100644
--- a/tests/cases/compiler/letDeclarations-scopes.ts
+++ b/tests/cases/compiler/letDeclarations-scopes.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // @target: ES6
 
 // global
diff --git a/tests/cases/compiler/letDeclarations-validContexts.ts b/tests/cases/compiler/letDeclarations-validContexts.ts
index baedfa2644c..2a4022901c1 100644
--- a/tests/cases/compiler/letDeclarations-validContexts.ts
+++ b/tests/cases/compiler/letDeclarations-validContexts.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // @target: ES6
 
 
diff --git a/tests/cases/compiler/noReachabilityErrorsOnEmptyStatement.ts b/tests/cases/compiler/noReachabilityErrorsOnEmptyStatement.ts
new file mode 100644
index 00000000000..81152c82b43
--- /dev/null
+++ b/tests/cases/compiler/noReachabilityErrorsOnEmptyStatement.ts
@@ -0,0 +1,3 @@
+function foo() {
+    return 1;;
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/null.ts b/tests/cases/compiler/null.ts
index eb88d387bcc..e8fa9a5d687 100644
--- a/tests/cases/compiler/null.ts
+++ b/tests/cases/compiler/null.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 var x=null; 
 var y=3+x;  
 var z=3+null; 
diff --git a/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts b/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts
index 21884031aec..12b99fb29ce 100644
--- a/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts
+++ b/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts
@@ -1 +1,3 @@
+// @allowUnreachableCode: true
+
 var f: (x: 'hi') => number = ('hi') => { return 1; };
\ No newline at end of file
diff --git a/tests/cases/compiler/reachabilityChecks1.ts b/tests/cases/compiler/reachabilityChecks1.ts
new file mode 100644
index 00000000000..6430556a203
--- /dev/null
+++ b/tests/cases/compiler/reachabilityChecks1.ts
@@ -0,0 +1,76 @@
+// @allowUnreachableCode: false
+// @preserveConstEnums: true
+
+while (true);
+var x = 1;
+
+module A {
+    while (true);
+    let x;
+}
+
+module A1 {
+    do {} while(true);
+    module A {
+        interface F {}
+    }
+}
+
+module A2 {
+    while (true);
+    module A {
+        var x = 1;
+    }
+}
+
+module A3 {
+    while (true);
+    type T = string;
+}
+
+module A4 {
+    while (true);
+    module A {
+        const enum E { X }
+    }
+}
+
+function f1(x) {
+    if (x) {
+        return;
+    }
+    else {
+        throw new Error("123");
+    }
+    var x;
+}
+
+function f2() {
+    return;
+    class A {
+    }
+}
+
+module B {
+    for (; ;);
+    module C {
+    }
+}
+
+function f3() {
+    do {
+    } while (true);
+    enum E {
+        X = 1
+    }
+}
+
+function f4() {
+    if (true) {
+        throw new Error();
+    }
+    const enum E {
+        X = 1
+    }
+}
+
diff --git a/tests/cases/compiler/reachabilityChecks2.ts b/tests/cases/compiler/reachabilityChecks2.ts
new file mode 100644
index 00000000000..5a7a8aaab58
--- /dev/null
+++ b/tests/cases/compiler/reachabilityChecks2.ts
@@ -0,0 +1,13 @@
+// @allowUnreachableCode: false
+// @preserveConstEnums: false
+
+while (true) { }
+const enum E { X }
+
+module A4 {
+    while (true);
+    module A {
+        const enum E { X }
+    }
+}
+
diff --git a/tests/cases/compiler/reachabilityChecks3.ts b/tests/cases/compiler/reachabilityChecks3.ts
new file mode 100644
index 00000000000..19f57e55b67
--- /dev/null
+++ b/tests/cases/compiler/reachabilityChecks3.ts
@@ -0,0 +1,16 @@
+// @allowUnusedLabels: false
+
+let x = 1;
+loop: while (true) {
+    if (x == 100) {
+        break;
+    }
+    else {
+        x++;
+    }
+}
+{
+    x: 100
+}
+
+var y = () => { f: 1 }
\ No newline at end of file
diff --git a/tests/cases/compiler/reachabilityChecks4.ts b/tests/cases/compiler/reachabilityChecks4.ts
new file mode 100644
index 00000000000..f07395ac38e
--- /dev/null
+++ b/tests/cases/compiler/reachabilityChecks4.ts
@@ -0,0 +1,15 @@
+// @noFallthroughCasesInSwitch: true
+
+function foo(x, y) {
+    switch (x) {
+        case 1:
+        case 2:
+            return 1;
+        case 3:
+            if (y) {
+                return 2;
+            }
+        case 4:
+            return 3;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/reachabilityChecks5.ts b/tests/cases/compiler/reachabilityChecks5.ts
new file mode 100644
index 00000000000..97df11ccb79
--- /dev/null
+++ b/tests/cases/compiler/reachabilityChecks5.ts
@@ -0,0 +1,131 @@
+// @allowUnreachableCode: false
+// @noImplicitReturns: true
+
+function f0(x): number {
+    while (true);
+}
+
+function f1(x): number {
+    if (x) {
+        return 1
+    }
+}
+
+function f2(x): number {
+    while (x) {
+        throw new Error();
+    }
+    return 1;
+}
+
+function f3(x): number {
+    while (x) {
+        throw new Error();
+    }
+}
+
+function f3_1 (x): number {
+    while (x) {
+    }
+    throw new Error();
+}
+
+function f4(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+    }
+    catch (e) {
+    }
+}
+
+function f5(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 2;
+    }
+}
+
+function f6(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+        else 
+        {
+            throw new Error();
+        }
+    }
+    catch (e) {
+    }
+}
+
+function f7(x): number {
+    try {
+        if (x) {
+            return 1;
+        }
+        else {
+            throw new Error();
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f8(x): number {
+    try {
+        if (true) {
+            x++;
+        }
+        else {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f9(x): number {
+    try {
+        while (false) {
+            return 1;
+        }
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f10(x): number {
+    try {
+        do {
+            x++;
+        } while (true);
+    }
+    catch (e) {
+        return 1;
+    }
+}
+
+function f11(x): number {
+    test:
+    try {
+        do {
+            do {
+                break test;
+            } while (true);
+            x++;
+        } while (true);
+    }
+    catch (e) {
+        return 1;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/recursiveMods.ts b/tests/cases/compiler/recursiveMods.ts
index fa07646ba72..84dbafff558 100644
--- a/tests/cases/compiler/recursiveMods.ts
+++ b/tests/cases/compiler/recursiveMods.ts
@@ -1,4 +1,6 @@
-//@module: commonjs
+// @allowUnreachableCode: true
+// @module: commonjs
+
 export module Foo {
 	export class C {}
 }
diff --git a/tests/cases/compiler/returnStatement1.ts b/tests/cases/compiler/returnStatement1.ts
index e87635b37d7..06d1bdb9569 100644
--- a/tests/cases/compiler/returnStatement1.ts
+++ b/tests/cases/compiler/returnStatement1.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function f() {
     return function (s) {
         var x = s;
diff --git a/tests/cases/compiler/sourceMapValidationLabeled.ts b/tests/cases/compiler/sourceMapValidationLabeled.ts
index 5993e82aacc..e36bdd9a0b3 100644
--- a/tests/cases/compiler/sourceMapValidationLabeled.ts
+++ b/tests/cases/compiler/sourceMapValidationLabeled.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
 // @sourcemap: true
+
 x:
 var b = 10;
\ No newline at end of file
diff --git a/tests/cases/compiler/systemModule8.ts b/tests/cases/compiler/systemModule8.ts
index c3e0c7c7437..4490b2a8529 100644
--- a/tests/cases/compiler/systemModule8.ts
+++ b/tests/cases/compiler/systemModule8.ts
@@ -1,3 +1,4 @@
+// @allowUnreachableCode: true
 // @module: system
 
 export var x;
diff --git a/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts b/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts
index b36f423be21..62311ee75c9 100644
--- a/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts
+++ b/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // expected error for all the LHS of compound assignments (arithmetic and addition)
 var value;
 
diff --git a/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts b/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts
index cd0fb64e0d2..d6bfd84fd9a 100644
--- a/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts
+++ b/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class Base { private p; }
 class Derived1 extends Base { private m; }
 class Derived2 extends Base { private n; }
diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts
index 00460181c2b..c22ed94087b 100644
--- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // typeof  operator on boolean type
 var BOOLEAN: boolean;
 
diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts
index 9abb602db06..57b22e3646c 100644
--- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // typeof  operator on enum type
 
 enum ENUM { };
diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts
index 06ac3e29784..81687e4f860 100644
--- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts
@@ -1,3 +1,4 @@
+// @allowUnusedLabels: true
 // typeof  operator on number type
 var NUMBER: number;
 var NUMBER1: number[] = [1, 2];
diff --git a/tests/cases/conformance/functions/functionImplementationErrors.ts b/tests/cases/conformance/functions/functionImplementationErrors.ts
index ddd3ba0a2c1..0a7c7812932 100644
--- a/tests/cases/conformance/functions/functionImplementationErrors.ts
+++ b/tests/cases/conformance/functions/functionImplementationErrors.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // FunctionExpression with no return type annotation with multiple return statements with unrelated types
 var f1 = function () {
     return '';
diff --git a/tests/cases/conformance/functions/functionImplementations.ts b/tests/cases/conformance/functions/functionImplementations.ts
index df36a0b4457..3c5adefd2e4 100644
--- a/tests/cases/conformance/functions/functionImplementations.ts
+++ b/tests/cases/conformance/functions/functionImplementations.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // FunctionExpression with no return type annotation and no return statement returns void
 var v: void = function () { } ();
 
diff --git a/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts b/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts
index 31407b88590..d35002e2f65 100644
--- a/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts
+++ b/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 class Foo {
     x: string;
     y() { }
diff --git a/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts b/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts
index cad137cc88d..62c0153f224 100644
--- a/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts
@@ -1,2 +1,4 @@
+// @allowUnusedLabels: true
+
 {a: 3}
 /x/
\ No newline at end of file
diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts
index 9cef599692c..64a9357706f 100644
--- a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts
index 2c3eadca7db..3e00bca659b 100644
--- a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts
index 26bea241a7a..a7b47ff071b 100644
--- a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts
index e00c222aa9c..5ba2bd69b11 100644
--- a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target1:
 target2:
 while (true) {
diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts
index d4db9399ed2..d6add980447 100644
--- a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 target:
 while (true) {
   function f() {
diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts
index 2c62180a2ab..bf7ea5c22c6 100644
--- a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts
+++ b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 target:
 while (true) {
 }
diff --git a/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts b/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts
index 88476ac4a78..b35204beb48 100644
--- a/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts
+++ b/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 /// Copyright (c) 2012 Ecma International.  All rights reserved. 
 /// Ecma International makes this code available under the terms and conditions set
 /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
diff --git a/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts
index 49bfaaca13f..cca94947a5d 100644
--- a/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 do {
     break;
 } while(true)
diff --git a/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts
index 20a93db4418..9cf07e1eef7 100644
--- a/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 for (; ;) {
     break;
 }
diff --git a/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts
index 5810d522182..ffc99ee904b 100644
--- a/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 for(var x in {}) {
     break;
 }
diff --git a/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts
index 7c93553a726..d164691db68 100644
--- a/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts
index cc21818b80f..142a8f8b3b5 100644
--- a/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts
index 9cda003e6f5..db49a13c8f7 100644
--- a/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked break not allowed
diff --git a/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts
index f5ce6ffa52f..3080a6b38a8 100644
--- a/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 switch ('') {
     case 'a':
         break;
diff --git a/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts
index c471e6552b9..e2a836b62a3 100644
--- a/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts
+++ b/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 while(true) {
     break;
 } 
diff --git a/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts
index d3d999ccb49..4685cc9f046 100644
--- a/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 do {
     continue;
 } while(true)
diff --git a/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts
index 1f8a3fc7b68..9b852df80c7 100644
--- a/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 for (; ;) {
     continue;
 }
diff --git a/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts
index 863caec2ccf..b5ccd8189ca 100644
--- a/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 for(var x in {}) {
     continue;
 }
diff --git a/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts
index 54192212ef7..dcf543ed7e3 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts
index 751cd9477ad..ba367ef87b7 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts
index be274005961..861d7e90629 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts
index cf913671315..ef94466ffba 100644
--- a/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts
+++ b/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts
@@ -1,3 +1,6 @@
+// @allowUnusedLabels: true
+// @allowUnreachableCode: true
+
 // All errors
 
 // naked continue not allowed
diff --git a/tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts b/tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts
new file mode 100644
index 00000000000..9f646e2c851
--- /dev/null
+++ b/tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts
@@ -0,0 +1,12 @@
+//@target: ES5
+
+var array = [1,2,3];
+var sum = 0;
+
+for (let num of array) {
+    if (sum === 0) {
+        array = [4,5,6]
+    }
+    
+    sum += num;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/statements/forStatements/forStatements.ts b/tests/cases/conformance/statements/forStatements/forStatements.ts
index 567c49c1098..1e65bdc2932 100644
--- a/tests/cases/conformance/statements/forStatements/forStatements.ts
+++ b/tests/cases/conformance/statements/forStatements/forStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface I {
     id: number;
 }
diff --git a/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts b/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts
index 0c2bb3d40dc..64317b23336 100644
--- a/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts
+++ b/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface I {
     id: number;
 }
diff --git a/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts b/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts
index 9f5557e7756..af19fd404df 100644
--- a/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts
+++ b/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // all expected to be valid
 
 for (var x: number; ;) { }
diff --git a/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts b/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts
index f2cd9aa43ee..03f042401d8 100644
--- a/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts
+++ b/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 interface I {
     id: number;
 }
diff --git a/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts b/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts
index aa382d4ec34..8cc294d01f7 100644
--- a/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts
+++ b/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 throw; 
 
 export throw null;
diff --git a/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts b/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts
index 4b9675f9d63..c5875327b50 100644
--- a/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts
+++ b/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function fn(x) {
     throw x;
 }
diff --git a/tests/cases/conformance/statements/throwStatements/throwStatements.ts b/tests/cases/conformance/statements/throwStatements/throwStatements.ts
index 8d155cbc8cf..07c09da93fc 100644
--- a/tests/cases/conformance/statements/throwStatements/throwStatements.ts
+++ b/tests/cases/conformance/statements/throwStatements/throwStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // all legal
 
 interface I {
diff --git a/tests/cases/conformance/types/localTypes/localTypes4.ts b/tests/cases/conformance/types/localTypes/localTypes4.ts
index bd31e76a80f..388d5efb637 100644
--- a/tests/cases/conformance/types/localTypes/localTypes4.ts
+++ b/tests/cases/conformance/types/localTypes/localTypes4.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 function f1() {
     // Type parameters are in scope in parameters and return types
     function f<T>(x: T): T {
diff --git a/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts b/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts
index c249d2e5671..5cb52588644 100644
--- a/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts
+++ b/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts
@@ -1,3 +1,5 @@
+// @allowUnusedLabels: true
+
 // interfaces do not permit private members, these are errors
 
 interface I {
diff --git a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts
index 7ea4f414e15..1cc499c7d6e 100644
--- a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts
+++ b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // Call signatures without a return type should infer one from the function body (if present)
 
 // Simple types
diff --git a/tests/cases/conformance/types/thisType/thisTypeErrors2.ts b/tests/cases/conformance/types/thisType/thisTypeErrors2.ts
new file mode 100644
index 00000000000..d29e714c4d0
--- /dev/null
+++ b/tests/cases/conformance/types/thisType/thisTypeErrors2.ts
@@ -0,0 +1,13 @@
+class Base {
+    constructor(a: this) {
+    }
+}
+class Generic<T> {
+}
+class Derived {
+    n: number;
+    constructor(public host: Generic<this>) {
+        let self: this = this;
+        this.n = 12;
+    }
+}
diff --git a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts
index 9b12363ff08..9864ddab488 100644
--- a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts
+++ b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // return type of a function with multiple returns is the BCT of each return statement
 // it is an error if there is no single BCT, these are error cases
 
diff --git a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts
index 41d4fddfbeb..03021bfdd10 100644
--- a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts
+++ b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts
@@ -1,3 +1,5 @@
+// @allowUnreachableCode: true
+
 // return type of a function with multiple returns is the BCT of each return statement
 // no errors expected here
 
diff --git a/tests/cases/conformance/types/union/unionTypeCallSignatures4.ts b/tests/cases/conformance/types/union/unionTypeCallSignatures4.ts
new file mode 100644
index 00000000000..1e27acd2083
--- /dev/null
+++ b/tests/cases/conformance/types/union/unionTypeCallSignatures4.ts
@@ -0,0 +1,25 @@
+type F1 = (a: string, b?: string) => void;
+type F2 = (a: string, b?: string, c?: string) => void;
+type F3 = (a: string, ...rest: string[]) => void;
+type F4 = (a: string, b?: string, ...rest: string[]) => void;
+type F5 = (a: string, b: string) => void;
+
+var f12: F1 | F2;
+f12("a");
+f12("a", "b");
+f12("a", "b", "c");  // error
+
+var f34: F3 | F4;
+f34("a");
+f34("a", "b");
+f34("a", "b", "c");
+
+var f1234: F1 | F2 | F3 | F4;
+f1234("a");
+f1234("a", "b");
+f1234("a", "b", "c");  // error
+
+var f12345: F1 | F2 | F3 | F4 | F5;
+f12345("a");  // error
+f12345("a", "b");
+f12345("a", "b", "c");  // error
diff --git a/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts b/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts
index bcb79811a62..7a52ddc2c32 100644
--- a/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts
+++ b/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts
@@ -1,4 +1,5 @@
 /// <reference path="fourslash.ts" />
+// @allowUnreachableCode: true
 
 ////        class alpha { static beta() return 5; } }
 ////  /**/  var gamma = alpha.beta() * 5;             
diff --git a/tests/cases/unittests/tsconfigParsing.ts b/tests/cases/unittests/tsconfigParsing.ts
new file mode 100644
index 00000000000..3603d22f314
--- /dev/null
+++ b/tests/cases/unittests/tsconfigParsing.ts
@@ -0,0 +1,86 @@
+/// <reference path="..\..\..\src\harness\harness.ts" />
+/// <reference path="..\..\..\src\compiler\commandLineParser.ts" />
+
+namespace ts {
+    describe('parseConfigFileTextToJson', () => {
+        function assertParseResult(jsonText: string, expectedConfigObject: { config?: any; error?: Diagnostic }) {
+            let parsed = ts.parseConfigFileTextToJson("/apath/tsconfig.json", jsonText);
+            assert.equal(JSON.stringify(parsed), JSON.stringify(expectedConfigObject));
+        }
+
+        function assertParseError(jsonText: string) {
+             let parsed = ts.parseConfigFileTextToJson("/apath/tsconfig.json", jsonText);
+             assert.isTrue(undefined === parsed.config);
+             assert.isTrue(undefined !== parsed.error);
+        }
+
+        it("returns empty config for file with only whitespaces", () => {
+            assertParseResult("", { config : {} });
+            assertParseResult(" ", { config : {} });
+        });
+
+        it("returns empty config for file with comments only", () => {
+            assertParseResult("// Comment", { config: {} });
+            assertParseResult("/* Comment*/", { config: {} });
+        });
+
+        it("returns empty config when config is empty object", () => {
+            assertParseResult("{}", { config: {} });
+        });
+
+        it("returns config object without comments", () => {
+            assertParseResult(
+                `{ // Excluded files
+                    "exclude": [
+                        // Exclude d.ts
+                        "file.d.ts"
+                    ]
+                }`, { config: { exclude: ["file.d.ts"] } });
+
+            assertParseResult(
+                `{
+                    /* Excluded
+                         Files
+                    */
+                    "exclude": [
+                        /* multiline comments can be in the middle of a line */"file.d.ts"
+                    ]
+                }`, { config: { exclude: ["file.d.ts"] } });
+        });
+
+        it("keeps string content untouched", () => {
+            assertParseResult(
+                `{
+                    "exclude": [
+                        "xx//file.d.ts"
+                    ]
+                }`, { config: { exclude: ["xx//file.d.ts"] } });
+         assertParseResult(
+                `{
+                    "exclude": [
+                        "xx/*file.d.ts*/"
+                    ]
+                }`, { config: { exclude: ["xx/*file.d.ts*/"] } });
+        });
+
+        it("handles escaped characters in strings correctly", () => {
+            assertParseResult(
+                `{
+                    "exclude": [
+                        "xx\\"//files"
+                    ]
+                }`, { config: { exclude: ["xx\"//files"] } });
+
+            assertParseResult(
+                `{
+                    "exclude": [
+                        "xx\\\\" // end of line comment
+                    ]
+                }`, { config: { exclude: ["xx\\"] } });
+         });
+
+        it("returns object with error when json is invalid", () => {
+             assertParseError("invalid");
+        });
+    });
+}
diff --git a/tests/webTestServer.ts b/tests/webTestServer.ts
index 18a1f05d47b..6ddc18f1344 100644
--- a/tests/webTestServer.ts
+++ b/tests/webTestServer.ts
@@ -192,7 +192,6 @@ function getRequestOperation(req: http.ServerRequest, filename: string) {
         }
         return RequestType.Unknown
     }
-    return RequestType.Unknown
 }
 
 function handleRequestOperation(req: http.ServerRequest, res: http.ServerResponse, operation: RequestType, reqPath: string) {
diff --git a/tslint.json b/tslint.json
index db10daa3fcc..3cafdbfd39c 100644
--- a/tslint.json
+++ b/tslint.json
@@ -39,6 +39,7 @@
         "no-inferrable-types": true,
         "no-null": true,
         "boolean-trivia": true,
-        "type-operator-spacing": true
+        "type-operator-spacing": true,
+        "prefer-const": true
   }
 }