diff --git a/.travis.yml b/.travis.yml
index 478e31c439831..bfc07e2b5100c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,12 +7,18 @@ node_js:
 
 sudo: false
 
+env:
+  - workerCount=3
+
 matrix:
   fast_finish: true
   include:
   - os: osx
     node_js: stable
     osx_image: xcode7.3
+    env: workerCount=2
+  allow_failures:
+  - os: osx
 
 branches:
   only:
@@ -28,3 +34,6 @@ install:
 cache:
   directories:
     - node_modules
+
+git:
+  depth: 1
diff --git a/Gulpfile.ts b/Gulpfile.ts
index bd4959700b089..295a7ce03d9d7 100644
--- a/Gulpfile.ts
+++ b/Gulpfile.ts
@@ -17,7 +17,7 @@ declare module "gulp-typescript" {
         stripInternal?: boolean;
         types?: string[];
     }
-    interface CompileStream extends NodeJS.ReadWriteStream {} // Either gulp or gulp-typescript has some odd typings which don't reflect reality, making this required
+    interface CompileStream extends NodeJS.ReadWriteStream { } // Either gulp or gulp-typescript has some odd typings which don't reflect reality, making this required
 }
 import * as insert from "gulp-insert";
 import * as sourcemaps from "gulp-sourcemaps";
@@ -34,7 +34,7 @@ import through2 = require("through2");
 import merge2 = require("merge2");
 import intoStream = require("into-stream");
 import * as os from "os";
-import Linter = require("tslint");
+import fold = require("travis-fold");
 const gulp = helpMaker(originalGulp);
 const mochaParallel = require("./scripts/mocha-parallel.js");
 const {runTestsInParallel} = mochaParallel;
@@ -65,7 +65,7 @@ const cmdLineOptions = minimist(process.argv.slice(2), {
     }
 });
 
-function exec(cmd: string, args: string[], complete: () => void = (() => {}), error: (e: any, status: number) => void = (() => {})) {
+function exec(cmd: string, args: string[], complete: () => void = (() => { }), error: (e: any, status: number) => void = (() => { })) {
     console.log(`${cmd} ${args.join(" ")}`);
     // TODO (weswig): Update child_process types to add windowsVerbatimArguments to the type definition
     const subshellFlag = isWin ? "/c" : "-c";
@@ -116,12 +116,12 @@ const es2015LibrarySources = [
 ];
 
 const es2015LibrarySourceMap = es2015LibrarySources.map(function(source) {
-   return  { target: "lib." + source, sources: ["header.d.ts", source] };
+    return { target: "lib." + source, sources: ["header.d.ts", source] };
 });
 
-const es2016LibrarySource = [ "es2016.array.include.d.ts" ];
+const es2016LibrarySource = ["es2016.array.include.d.ts"];
 
-const es2016LibrarySourceMap = es2016LibrarySource.map(function (source) {
+const es2016LibrarySourceMap = es2016LibrarySource.map(function(source) {
     return { target: "lib." + source, sources: ["header.d.ts", source] };
 });
 
@@ -130,38 +130,38 @@ const es2017LibrarySource = [
     "es2017.sharedmemory.d.ts"
 ];
 
-const es2017LibrarySourceMap = es2017LibrarySource.map(function (source) {
+const es2017LibrarySourceMap = es2017LibrarySource.map(function(source) {
     return { target: "lib." + source, sources: ["header.d.ts", source] };
 });
 
 const hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"];
 
 const librarySourceMap = [
-        // Host library
-        { target: "lib.dom.d.ts", sources: ["header.d.ts", "dom.generated.d.ts"] },
-        { target: "lib.dom.iterable.d.ts", sources: ["header.d.ts", "dom.iterable.d.ts"] },
-        { target: "lib.webworker.d.ts", sources: ["header.d.ts", "webworker.generated.d.ts"] },
-        { target: "lib.scripthost.d.ts", sources: ["header.d.ts", "scripthost.d.ts"] },
-
-        // JavaScript library
-        { target: "lib.es5.d.ts", sources: ["header.d.ts", "es5.d.ts"] },
-        { target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] },
-        { target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] },
-        { target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] },
-
-        // JavaScript + all host library
-        { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
-        { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
+    // Host library
+    { target: "lib.dom.d.ts", sources: ["header.d.ts", "dom.generated.d.ts"] },
+    { target: "lib.dom.iterable.d.ts", sources: ["header.d.ts", "dom.iterable.d.ts"] },
+    { target: "lib.webworker.d.ts", sources: ["header.d.ts", "webworker.generated.d.ts"] },
+    { target: "lib.scripthost.d.ts", sources: ["header.d.ts", "scripthost.d.ts"] },
+
+    // JavaScript library
+    { target: "lib.es5.d.ts", sources: ["header.d.ts", "es5.d.ts"] },
+    { target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] },
+    { target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] },
+    { target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] },
+
+    // JavaScript + all host library
+    { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
+    { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
 ].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap);
 
-const libraryTargets = librarySourceMap.map(function (f) {
+const libraryTargets = librarySourceMap.map(function(f) {
     return path.join(builtLocalDirectory, f.target);
 });
 
 for (const i in libraryTargets) {
     const entry = librarySourceMap[i];
     const target = libraryTargets[i];
-    const sources = [copyright].concat(entry.sources.map(function (s) {
+    const sources = [copyright].concat(entry.sources.map(function(s) {
         return path.join(libraryDirectory, s);
     }));
     gulp.task(target, false, [], function() {
@@ -391,7 +391,7 @@ gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => {
         .pipe(sourcemaps.init())
         .pipe(tsc(servicesProject));
     const completedJs = js.pipe(prependCopyright())
-            .pipe(sourcemaps.write("."));
+        .pipe(sourcemaps.write("."));
     const completedDts = dts.pipe(prependCopyright(/*outputCopyright*/true))
         .pipe(insert.transform((contents, file) => {
             file.path = standaloneDefinitionsFile;
@@ -434,22 +434,22 @@ const tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverli
 
 gulp.task(tsserverLibraryFile, false, [servicesFile], (done) => {
     const serverLibraryProject = tsc.createProject("src/server/tsconfig.library.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
-    const {js, dts}: {js: NodeJS.ReadableStream, dts: NodeJS.ReadableStream} = serverLibraryProject.src()
+    const {js, dts}: { js: NodeJS.ReadableStream, dts: NodeJS.ReadableStream } = serverLibraryProject.src()
         .pipe(sourcemaps.init())
         .pipe(newer(tsserverLibraryFile))
         .pipe(tsc(serverLibraryProject));
 
     return merge2([
         js.pipe(prependCopyright())
-          .pipe(sourcemaps.write("."))
-          .pipe(gulp.dest(builtLocalDirectory)),
+            .pipe(sourcemaps.write("."))
+            .pipe(gulp.dest(builtLocalDirectory)),
         dts.pipe(prependCopyright())
-          .pipe(gulp.dest(builtLocalDirectory))
+            .pipe(gulp.dest(builtLocalDirectory))
     ]);
 });
 
 gulp.task("lssl", "Builds language service server library", [tsserverLibraryFile]);
-gulp.task("local", "Builds the full compiler and services", [builtLocalCompiler, servicesFile, serverFile, builtGeneratedDiagnosticMessagesJSON]);
+gulp.task("local", "Builds the full compiler and services", [builtLocalCompiler, servicesFile, serverFile, builtGeneratedDiagnosticMessagesJSON, tsserverLibraryFile]);
 gulp.task("tsc", "Builds only the compiler", [builtLocalCompiler]);
 
 
@@ -476,7 +476,7 @@ gulp.task(specMd, false, [word2mdJs], (done) => {
     const specMDFullPath = path.resolve(specMd);
     const cmd = "cscript //nologo " + word2mdJs + " \"" + specWordFullPath + "\" " + "\"" + specMDFullPath + "\"";
     console.log(cmd);
-    cp.exec(cmd, function () {
+    cp.exec(cmd, function() {
         done();
     });
 });
@@ -492,18 +492,18 @@ gulp.task("dontUseDebugMode", false, [], (done) => { useDebugMode = false; done(
 
 gulp.task("VerifyLKG", false, [], () => {
     const expectedFiles = [builtLocalCompiler, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile].concat(libraryTargets);
-    const missingFiles = expectedFiles.filter(function (f) {
+    const missingFiles = expectedFiles.filter(function(f) {
         return !fs.existsSync(f);
     });
     if (missingFiles.length > 0) {
         throw new Error("Cannot replace the LKG unless all built targets are present in directory " + builtLocalDirectory +
-                    ". The following files are missing:\n" + missingFiles.join("\n"));
+            ". The following files are missing:\n" + missingFiles.join("\n"));
     }
     // Copy all the targets into the LKG directory
     return gulp.src(expectedFiles).pipe(gulp.dest(LKGDirectory));
 });
 
-gulp.task("LKGInternal", false, ["lib", "local", "lssl"]);
+gulp.task("LKGInternal", false, ["lib", "local"]);
 
 gulp.task("LKG", "Makes a new LKG out of the built js files", ["clean", "dontUseDebugMode"], () => {
     return runSequence("LKGInternal", "VerifyLKG");
@@ -531,8 +531,6 @@ const localRwcBaseline = path.join(internalTests, "baselines/rwc/local");
 const refRwcBaseline = path.join(internalTests, "baselines/rwc/reference");
 
 const localTest262Baseline = path.join(internalTests, "baselines/test262/local");
-const refTest262Baseline = path.join(internalTests, "baselines/test262/reference");
-
 
 gulp.task("tests", "Builds the test infrastructure using the built compiler", [run]);
 gulp.task("tests-debug", "Builds the test sources and automation in debug mode", () => {
@@ -553,7 +551,7 @@ function restoreSavedNodeEnv() {
     process.env.NODE_ENV = savedNodeEnv;
 }
 
-let testTimeout = 20000;
+let testTimeout = 40000;
 function runConsoleTests(defaultReporter: string, runInParallel: boolean, done: (e?: any) => void) {
     const lintFlag = cmdLineOptions["lint"];
     cleanTestDirs((err) => {
@@ -627,7 +625,7 @@ function runConsoleTests(defaultReporter: string, runInParallel: boolean, done:
             }
             args.push(run);
             setNodeEnvToDevelopment();
-            runTestsInParallel(taskConfigsFolder, run, { testTimeout: testTimeout, noColors: colors === " --no-colors " }, function (err) {
+            runTestsInParallel(taskConfigsFolder, run, { testTimeout: testTimeout, noColors: colors === " --no-colors " }, function(err) {
                 // last worker clean everything and runs linter in case if there were no errors
                 del(taskConfigsFolder).then(() => {
                     if (!err) {
@@ -679,7 +677,7 @@ gulp.task("runtests",
     ["build-rules", "tests"],
     (done) => {
         runConsoleTests("mocha-fivemat-progress-reporter", /*runInParallel*/ false, done);
-});
+    });
 
 const nodeServerOutFile = "tests/webTestServer.js";
 const nodeServerInFile = "tests/webTestServer.ts";
@@ -811,32 +809,36 @@ gulp.task("diff-rwc", "Diffs the RWC baselines using the diff tool specified by
     exec(getDiffTool(), [refRwcBaseline, localRwcBaseline], done, done);
 });
 
-
-gulp.task("baseline-accept", "Makes the most recent test results the new baseline, overwriting the old baseline", (done) => {
-    const softAccept = cmdLineOptions["soft"];
-    if (!softAccept) {
-        del(refBaseline).then(() => {
-            fs.renameSync(localBaseline, refBaseline);
-            done();
-        }, done);
-    }
-    else {
-        gulp.src(localBaseline)
-          .pipe(gulp.dest(refBaseline))
-          .on("end", () => {
-              del(path.join(refBaseline, "local")).then(() => done(), done);
-          });
-    }
+gulp.task("baseline-accept", "Makes the most recent test results the new baseline, overwriting the old baseline", () => {
+    return baselineAccept("");
 });
+
+function baselineAccept(subfolder = "") {
+    return merge2(baselineCopy(subfolder), baselineDelete(subfolder));
+}
+
+function baselineCopy(subfolder = "") {
+    return gulp.src([`tests/baselines/local/${subfolder}/**`, `!tests/baselines/local/${subfolder}/**/*.delete`])
+        .pipe(gulp.dest(refBaseline));
+}
+
+function baselineDelete(subfolder = "") {
+    return gulp.src(["tests/baselines/local/**/*.delete"])
+        .pipe(insert.transform((content, fileObj) => {
+            const target = path.join(refBaseline, fileObj.relative.substr(0, fileObj.relative.length - ".delete".length));
+            del.sync(target);
+            del.sync(fileObj.path);
+            return "";
+        }));
+}
+
 gulp.task("baseline-accept-rwc", "Makes the most recent rwc test results the new baseline, overwriting the old baseline", () => {
-    return del(refRwcBaseline).then(() => {
-        fs.renameSync(localRwcBaseline, refRwcBaseline);
-    });
+    return baselineAccept("rwc");
 });
+
+
 gulp.task("baseline-accept-test262", "Makes the most recent test262 test results the new baseline, overwriting the old baseline", () => {
-    return del(refTest262Baseline).then(() => {
-        fs.renameSync(localTest262Baseline, refTest262Baseline);
-    });
+    return baselineAccept("test262");
 });
 
 
@@ -928,26 +930,6 @@ gulp.task("build-rules", "Compiles tslint rules to js", () => {
         .pipe(gulp.dest(dest));
 });
 
-function getLinterOptions() {
-    return {
-        configuration: require("./tslint.json"),
-        formatter: "prose",
-        formattersDirectory: undefined,
-        rulesDirectory: "built/local/tslint"
-    };
-}
-
-function lintFileContents(options, path, contents) {
-    const ll = new Linter(path, contents, options);
-    console.log("Linting '" + path + "'.");
-    return ll.lint();
-}
-
-function lintFile(options, path) {
-    const contents = fs.readFileSync(path, "utf8");
-    return lintFileContents(options, path, contents);
-}
-
 const lintTargets = [
     "Gulpfile.ts",
     "src/compiler/**/*.ts",
@@ -959,27 +941,72 @@ const lintTargets = [
     "tests/*.ts", "tests/webhost/*.ts" // Note: does *not* descend recursively
 ];
 
+function sendNextFile(files: {path: string}[], child: cp.ChildProcess, callback: (failures: number) => void, failures: number) {
+    const file = files.pop();
+    if (file) {
+        console.log(`Linting '${file.path}'.`);
+        child.send({ kind: "file", name: file.path });
+    }
+    else {
+        child.send({ kind: "close" });
+        callback(failures);
+    }
+}
+
+function spawnLintWorker(files: {path: string}[], callback: (failures: number) => void) {
+    const child = cp.fork("./scripts/parallel-lint");
+    let failures = 0;
+    child.on("message", function(data) {
+        switch (data.kind) {
+            case "result":
+                if (data.failures > 0) {
+                    failures += data.failures;
+                    console.log(data.output);
+                }
+                sendNextFile(files, child, callback, failures);
+                break;
+            case "error":
+                console.error(data.error);
+                failures++;
+                sendNextFile(files, child, callback, failures);
+                break;
+        }
+    });
+    sendNextFile(files, child, callback, failures);
+}
 
 gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are: --f[iles]=regex", ["build-rules"], () => {
     const fileMatcher = RegExp(cmdLineOptions["files"]);
-    const lintOptions = getLinterOptions();
-    let failed = 0;
-    return gulp.src(lintTargets)
-        .pipe(insert.transform((contents, file) => {
-            if (!fileMatcher.test(file.path)) return contents;
-            const result = lintFile(lintOptions, file.path);
-            if (result.failureCount > 0) {
-                console.log(result.output);
-                failed += result.failureCount;
+    if (fold.isTravis()) console.log(fold.start("lint"));
+
+    let files: {stat: fs.Stats, path: string}[] = [];
+    return gulp.src(lintTargets, { read: false })
+        .pipe(through2.obj((chunk, enc, cb) => {
+            files.push(chunk);
+            cb();
+        }, (cb) => {
+            files = files.filter(file =>  fileMatcher.test(file.path)).sort((filea, fileb) => filea.stat.size - fileb.stat.size);
+            const workerCount = (process.env.workerCount && +process.env.workerCount) || os.cpus().length;
+            for (let i = 0; i < workerCount; i++) {
+                spawnLintWorker(files, finished);
             }
-            return contents; // TODO (weswig): Automatically apply fixes? :3
-        }))
-        .on("end", () => {
-            if (failed > 0) {
-                console.error("Linter errors.");
-                process.exit(1);
+
+            let completed = 0;
+            let failures = 0;
+            function finished(fails) {
+                completed++;
+                failures += fails;
+                if (completed === workerCount) {
+                    if (fold.isTravis()) console.log(fold.end("lint"));
+                    if (failures > 0) {
+                        throw new Error(`Linter errors: ${failures}`);
+                    }
+                    else {
+                        cb();
+                    }
+                }
             }
-        });
+        }));
 });
 
 
diff --git a/Jakefile.js b/Jakefile.js
index 3047d792af293..fe8ba4742fe5b 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -4,7 +4,7 @@ var fs = require("fs");
 var os = require("os");
 var path = require("path");
 var child_process = require("child_process");
-var Linter = require("tslint");
+var fold = require("travis-fold");
 var runTestsInParallel = require("./scripts/mocha-parallel").runTestsInParallel;
 
 // Variables
@@ -27,9 +27,31 @@ var thirdParty = "ThirdPartyNoticeText.txt";
 // add node_modules to path so we don't need global modules, prefer the modules by adding them first
 var nodeModulesPathPrefix = path.resolve("./node_modules/.bin/") + path.delimiter;
 if (process.env.path !== undefined) {
-   process.env.path = nodeModulesPathPrefix + process.env.path;
+    process.env.path = nodeModulesPathPrefix + process.env.path;
 } else if (process.env.PATH !== undefined) {
-   process.env.PATH = nodeModulesPathPrefix + process.env.PATH;
+    process.env.PATH = nodeModulesPathPrefix + process.env.PATH;
+}
+
+function toNs(diff) {
+    return diff[0] * 1e9 + diff[1];
+}
+
+function mark() {
+    if (!fold.isTravis()) return;
+    var stamp = process.hrtime();
+    var id = Math.floor(Math.random() * 0xFFFFFFFF).toString(16);
+    console.log("travis_time:start:" + id + "\r");
+    return {
+        stamp: stamp,
+        id: id
+    };
+}
+
+function measure(marker) {
+    if (!fold.isTravis()) return;
+    var diff = process.hrtime(marker.stamp);
+    var total = [marker.stamp[0] + diff[0], marker.stamp[1] + diff[1]];
+    console.log("travis_time:end:" + marker.id + ":start=" + toNs(marker.stamp) + ",finish=" + toNs(total) + ",duration=" + toNs(diff) + "\r");
 }
 
 var compilerSources = [
@@ -184,7 +206,8 @@ var harnessSources = harnessCoreSources.concat([
     "convertCompilerOptionsFromJson.ts",
     "convertTypingOptionsFromJson.ts",
     "tsserverProjectSystem.ts",
-    "matchFiles.ts"
+    "matchFiles.ts",
+    "initializeTSConfig.ts",
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
@@ -208,11 +231,11 @@ var es2015LibrarySources = [
     "es2015.symbol.wellknown.d.ts"
 ];
 
-var es2015LibrarySourceMap = es2015LibrarySources.map(function(source) {
-   return  { target: "lib." + source, sources: ["header.d.ts", source] };
+var es2015LibrarySourceMap = es2015LibrarySources.map(function (source) {
+    return { target: "lib." + source, sources: ["header.d.ts", source] };
 });
 
-var es2016LibrarySource = [ "es2016.array.include.d.ts" ];
+var es2016LibrarySource = ["es2016.array.include.d.ts"];
 
 var es2016LibrarySourceMap = es2016LibrarySource.map(function (source) {
     return { target: "lib." + source, sources: ["header.d.ts", source] };
@@ -230,21 +253,21 @@ var es2017LibrarySourceMap = es2017LibrarySource.map(function (source) {
 var hostsLibrarySources = ["dom.generated.d.ts", "webworker.importscripts.d.ts", "scripthost.d.ts"];
 
 var librarySourceMap = [
-        // Host library
-        { target: "lib.dom.d.ts", sources: ["header.d.ts", "dom.generated.d.ts"] },
-        { target: "lib.dom.iterable.d.ts", sources: ["header.d.ts", "dom.iterable.d.ts"] },
-        { target: "lib.webworker.d.ts", sources: ["header.d.ts", "webworker.generated.d.ts"] },
-        { target: "lib.scripthost.d.ts", sources: ["header.d.ts", "scripthost.d.ts"] },
-
-        // JavaScript library
-        { target: "lib.es5.d.ts", sources: ["header.d.ts", "es5.d.ts"] },
-        { target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] },
-        { target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] },
-        { target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] },
-
-        // JavaScript + all host library
-        { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
-        { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
+    // Host library
+    { target: "lib.dom.d.ts", sources: ["header.d.ts", "dom.generated.d.ts"] },
+    { target: "lib.dom.iterable.d.ts", sources: ["header.d.ts", "dom.iterable.d.ts"] },
+    { target: "lib.webworker.d.ts", sources: ["header.d.ts", "webworker.generated.d.ts"] },
+    { target: "lib.scripthost.d.ts", sources: ["header.d.ts", "scripthost.d.ts"] },
+
+    // JavaScript library
+    { target: "lib.es5.d.ts", sources: ["header.d.ts", "es5.d.ts"] },
+    { target: "lib.es2015.d.ts", sources: ["header.d.ts", "es2015.d.ts"] },
+    { target: "lib.es2016.d.ts", sources: ["header.d.ts", "es2016.d.ts"] },
+    { target: "lib.es2017.d.ts", sources: ["header.d.ts", "es2017.d.ts"] },
+
+    // JavaScript + all host library
+    { target: "lib.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(hostsLibrarySources) },
+    { target: "lib.es6.d.ts", sources: ["header.d.ts", "es5.d.ts"].concat(es2015LibrarySources, hostsLibrarySources, "dom.iterable.d.ts") }
 ].concat(es2015LibrarySourceMap, es2016LibrarySourceMap, es2017LibrarySourceMap);
 
 var libraryTargets = librarySourceMap.map(function (f) {
@@ -260,7 +283,7 @@ function prependFile(prefixFile, destinationFile) {
         fail(destinationFile + " failed to be created!");
     }
     var temp = "temptemp";
-    jake.cpR(prefixFile, temp, {silent: true});
+    jake.cpR(prefixFile, temp, { silent: true });
     fs.appendFileSync(temp, fs.readFileSync(destinationFile));
     fs.renameSync(temp, destinationFile);
 }
@@ -272,11 +295,11 @@ function concatenateFiles(destinationFile, sourceFiles) {
     if (!fs.existsSync(sourceFiles[0])) {
         fail(sourceFiles[0] + " does not exist!");
     }
-    jake.cpR(sourceFiles[0], temp, {silent: true});
+    jake.cpR(sourceFiles[0], temp, { silent: true });
     // append all files in sequence
     for (var i = 1; i < sourceFiles.length; i++) {
         if (!fs.existsSync(sourceFiles[i])) {
-                fail(sourceFiles[i] + " does not exist!");
+            fail(sourceFiles[i] + " does not exist!");
         }
         fs.appendFileSync(temp, fs.readFileSync(sourceFiles[i]));
     }
@@ -314,9 +337,10 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
         if (process.env.USE_TRANSFORMS === "false") {
             useBuiltCompiler = false;
         }
+        var startCompileTime = mark();
         opts = opts || {};
         var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
-        var options = "--noImplicitAny --noImplicitThis --noEmitOnError --types " 
+        var options = "--noImplicitAny --noImplicitThis --noEmitOnError --types "
         if (opts.types) {
             options += opts.types.join(",");
         }
@@ -346,7 +370,7 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
             options += " --module commonjs";
         }
 
-        if(opts.noResolve) {
+        if (opts.noResolve) {
             options += " --noResolve";
         }
 
@@ -373,13 +397,13 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
 
         var ex = jake.createExec([cmd]);
         // Add listeners for output and error
-        ex.addListener("stdout", function(output) {
+        ex.addListener("stdout", function (output) {
             process.stdout.write(output);
         });
-        ex.addListener("stderr", function(error) {
+        ex.addListener("stderr", function (error) {
             process.stderr.write(error);
         });
-        ex.addListener("cmdEnd", function() {
+        ex.addListener("cmdEnd", function () {
             if (!useDebugMode && prefixes && fs.existsSync(outFile)) {
                 for (var i in prefixes) {
                     prependFile(prefixes[i], outFile);
@@ -390,14 +414,16 @@ function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts
                 callback();
             }
 
+            measure(startCompileTime);
             complete();
         });
-        ex.addListener("error", function() {
+        ex.addListener("error", function () {
             fs.unlinkSync(outFile);
             fail("Compilation of " + outFile + " unsuccessful");
+            measure(startCompileTime);
         });
         ex.run();
-    }, {async: true});
+    }, { async: true });
 }
 
 // Prerequisite task for built directory and library typings
@@ -410,7 +436,7 @@ for (var i in libraryTargets) {
         var sources = [copyright].concat(entry.sources.map(function (s) {
             return path.join(libraryDirectory, s);
         }));
-        file(target, [builtLocalDirectory].concat(sources), function() {
+        file(target, [builtLocalDirectory].concat(sources), function () {
             concatenateFiles(target, sources);
         });
     })(i);
@@ -433,30 +459,30 @@ file(processDiagnosticMessagesTs);
 
 // processDiagnosticMessages script
 compileFile(processDiagnosticMessagesJs,
-            [processDiagnosticMessagesTs],
-            [processDiagnosticMessagesTs],
-            [],
+    [processDiagnosticMessagesTs],
+    [processDiagnosticMessagesTs],
+    [],
             /*useBuiltCompiler*/ false);
 
 // The generated diagnostics map; built for the compiler and for the 'generate-diagnostics' task
 file(diagnosticInfoMapTs, [processDiagnosticMessagesJs, diagnosticMessagesJson], function () {
-    var cmd = host + " " + processDiagnosticMessagesJs + " "  + diagnosticMessagesJson;
+    var cmd = host + " " + processDiagnosticMessagesJs + " " + diagnosticMessagesJson;
     console.log(cmd);
     var ex = jake.createExec([cmd]);
     // Add listeners for output and error
-    ex.addListener("stdout", function(output) {
+    ex.addListener("stdout", function (output) {
         process.stdout.write(output);
     });
-    ex.addListener("stderr", function(error) {
+    ex.addListener("stderr", function (error) {
         process.stderr.write(error);
     });
-    ex.addListener("cmdEnd", function() {
+    ex.addListener("cmdEnd", function () {
         complete();
     });
     ex.run();
-}, {async: true});
+}, { async: true });
 
-file(builtGeneratedDiagnosticMessagesJSON,[generatedDiagnosticMessagesJSON], function() {
+file(builtGeneratedDiagnosticMessagesJSON, [generatedDiagnosticMessagesJSON], function () {
     if (fs.existsSync(builtLocalDirectory)) {
         jake.cpR(generatedDiagnosticMessagesJSON, builtGeneratedDiagnosticMessagesJSON);
     }
@@ -474,17 +500,17 @@ var programTs = path.join(compilerDirectory, "program.ts");
 file(configureNightlyTs);
 
 compileFile(/*outfile*/configureNightlyJs,
-            /*sources*/ [configureNightlyTs],
-            /*prereqs*/ [configureNightlyTs],
-            /*prefixes*/ [],
+            /*sources*/[configureNightlyTs],
+            /*prereqs*/[configureNightlyTs],
+            /*prefixes*/[],
             /*useBuiltCompiler*/ false,
-            { noOutFile: false, generateDeclarations: false, keepComments: false, noResolve: false, stripInternal: false });
+    { noOutFile: false, generateDeclarations: false, keepComments: false, noResolve: false, stripInternal: false });
 
-task("setDebugMode", function() {
+task("setDebugMode", function () {
     useDebugMode = true;
 });
 
-task("configure-nightly", [configureNightlyJs], function() {
+task("configure-nightly", [configureNightlyJs], function () {
     var cmd = host + " " + configureNightlyJs + " " + packageJson + " " + programTs;
     console.log(cmd);
     exec(cmd);
@@ -525,63 +551,65 @@ var nodePackageFile = path.join(builtLocalDirectory, "typescript.js");
 var nodeDefinitionsFile = path.join(builtLocalDirectory, "typescript.d.ts");
 var nodeStandaloneDefinitionsFile = path.join(builtLocalDirectory, "typescript_standalone.d.ts");
 
-compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources),
-            /*prefixes*/ [copyright],
+compileFile(servicesFile, servicesSources, [builtLocalDirectory, copyright].concat(servicesSources),
+            /*prefixes*/[copyright],
             /*useBuiltCompiler*/ true,
-            /*opts*/ { noOutFile: false,
-                generateDeclarations: true,
-                preserveConstEnums: true,
-                keepComments: true,
-                noResolve: false,
-                stripInternal: true
-            },
+            /*opts*/ {
+        noOutFile: false,
+        generateDeclarations: true,
+        preserveConstEnums: true,
+        keepComments: true,
+        noResolve: false,
+        stripInternal: true
+    },
             /*callback*/ function () {
-                jake.cpR(servicesFile, nodePackageFile, {silent: true});
+        jake.cpR(servicesFile, nodePackageFile, { silent: true });
 
-                prependFile(copyright, standaloneDefinitionsFile);
+        prependFile(copyright, standaloneDefinitionsFile);
 
-                // Stanalone/web definition file using global 'ts' namespace
-                jake.cpR(standaloneDefinitionsFile, nodeDefinitionsFile, {silent: true});
-                var definitionFileContents = fs.readFileSync(nodeDefinitionsFile).toString();
-                definitionFileContents = definitionFileContents.replace(/^(\s*)(export )?const enum (\S+) {(\s*)$/gm, '$1$2enum $3 {$4');
-                fs.writeFileSync(standaloneDefinitionsFile, definitionFileContents);
+        // Stanalone/web definition file using global 'ts' namespace
+        jake.cpR(standaloneDefinitionsFile, nodeDefinitionsFile, { silent: true });
+        var definitionFileContents = fs.readFileSync(nodeDefinitionsFile).toString();
+        definitionFileContents = definitionFileContents.replace(/^(\s*)(export )?const enum (\S+) {(\s*)$/gm, '$1$2enum $3 {$4');
+        fs.writeFileSync(standaloneDefinitionsFile, definitionFileContents);
 
-                // Official node package definition file, pointed to by 'typings' in package.json
-                // Created by appending 'export = ts;' at the end of the standalone file to turn it into an external module
-                var nodeDefinitionsFileContents = definitionFileContents + "\r\nexport = ts;";
-                fs.writeFileSync(nodeDefinitionsFile, nodeDefinitionsFileContents);
+        // Official node package definition file, pointed to by 'typings' in package.json
+        // Created by appending 'export = ts;' at the end of the standalone file to turn it into an external module
+        var nodeDefinitionsFileContents = definitionFileContents + "\r\nexport = ts;";
+        fs.writeFileSync(nodeDefinitionsFile, nodeDefinitionsFileContents);
 
-                // Node package definition file to be distributed without the package. Created by replacing
-                // 'ts' namespace with '"typescript"' as a module.
-                var nodeStandaloneDefinitionsFileContents = definitionFileContents.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
-                fs.writeFileSync(nodeStandaloneDefinitionsFile, nodeStandaloneDefinitionsFileContents);
-            });
+        // Node package definition file to be distributed without the package. Created by replacing
+        // 'ts' namespace with '"typescript"' as a module.
+        var nodeStandaloneDefinitionsFileContents = definitionFileContents.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
+        fs.writeFileSync(nodeStandaloneDefinitionsFile, nodeStandaloneDefinitionsFileContents);
+    });
 
 compileFile(
     servicesFileInBrowserTest,
     servicesSources,
     [builtLocalDirectory, copyright].concat(servicesSources),
-    /*prefixes*/ [copyright],
+    /*prefixes*/[copyright],
     /*useBuiltCompiler*/ true,
-    { noOutFile: false,
-      generateDeclarations: true,
-      preserveConstEnums: true,
-      keepComments: true,
-      noResolve: false,
-      stripInternal: true,
-      noMapRoot: true,
-      inlineSourceMap: true
-     });
+    {
+        noOutFile: false,
+        generateDeclarations: true,
+        preserveConstEnums: true,
+        keepComments: true,
+        noResolve: false,
+        stripInternal: true,
+        noMapRoot: true,
+        inlineSourceMap: true
+    });
 
 var serverFile = path.join(builtLocalDirectory, "tsserver.js");
-compileFile(serverFile, serverSources,[builtLocalDirectory, copyright].concat(serverSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { types: ["node"] });
+compileFile(serverFile, serverSources, [builtLocalDirectory, copyright].concat(serverSources), /*prefixes*/[copyright], /*useBuiltCompiler*/ true, { types: ["node"] });
 var tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js");
 var tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverlibrary.d.ts");
 compileFile(
     tsserverLibraryFile,
     languageServiceLibrarySources,
-    [builtLocalDirectory, copyright].concat(languageServiceLibrarySources),
-    /*prefixes*/ [copyright],
+    [builtLocalDirectory, copyright, builtLocalCompiler].concat(languageServiceLibrarySources).concat(libraryTargets),
+    /*prefixes*/[copyright],
     /*useBuiltCompiler*/ true,
     { noOutFile: false, generateDeclarations: true });
 
@@ -589,9 +617,19 @@ compileFile(
 desc("Builds language service server library");
 task("lssl", [tsserverLibraryFile, tsserverLibraryDefinitionFile]);
 
+desc("Emit the start of the build fold");
+task("build-fold-start", [], function () {
+    if (fold.isTravis()) console.log(fold.start("build"));
+});
+
+desc("Emit the end of the build fold");
+task("build-fold-end", [], function () {
+    if (fold.isTravis()) console.log(fold.end("build"));
+});
+
 // Local target to build the compiler and services
 desc("Builds the full compiler and services");
-task("local", ["generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON]);
+task("local", ["build-fold-start", "generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON, "lssl", "build-fold-end"]);
 
 // Local target to build only tsc.js
 desc("Builds only the compiler");
@@ -599,7 +637,7 @@ task("tsc", ["generate-diagnostics", "lib", tscFile]);
 
 // Local target to build the compiler and services
 desc("Sets release mode flag");
-task("release", function() {
+task("release", function () {
     useDebugMode = false;
 });
 
@@ -609,7 +647,7 @@ task("default", ["local"]);
 
 // Cleans the built directory
 desc("Cleans the compiler output, declare files, and tests");
-task("clean", function() {
+task("clean", function () {
     jake.rmRf(builtDirectory);
 });
 
@@ -623,9 +661,9 @@ file(word2mdTs);
 
 // word2md script
 compileFile(word2mdJs,
-            [word2mdTs],
-            [word2mdTs],
-            [],
+    [word2mdTs],
+    [word2mdTs],
+    [],
             /*useBuiltCompiler*/ false);
 
 // The generated spec.md; built for the 'generate-spec' task
@@ -637,7 +675,7 @@ file(specMd, [word2mdJs, specWord], function () {
     child_process.exec(cmd, function () {
         complete();
     });
-}, {async: true});
+}, { async: true });
 
 
 desc("Generates a Markdown version of the Language Specification");
@@ -646,14 +684,14 @@ task("generate-spec", [specMd]);
 
 // Makes a new LKG. This target does not build anything, but errors if not all the outputs are present in the built/local directory
 desc("Makes a new LKG out of the built js files");
-task("LKG", ["clean", "release", "local", "lssl"].concat(libraryTargets), function() {
+task("LKG", ["clean", "release", "local"].concat(libraryTargets), function () {
     var expectedFiles = [tscFile, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile].concat(libraryTargets);
     var missingFiles = expectedFiles.filter(function (f) {
         return !fs.existsSync(f);
     });
     if (missingFiles.length > 0) {
         fail("Cannot replace the LKG unless all built targets are present in directory " + builtLocalDirectory +
-                    ". The following files are missing:\n" + missingFiles.join("\n"));
+            ". The following files are missing:\n" + missingFiles.join("\n"));
     }
     // Copy all the targets into the LKG directory
     jake.mkdirP(LKGDirectory);
@@ -674,8 +712,8 @@ var run = path.join(builtLocalDirectory, "run.js");
 compileFile(
     /*outFile*/ run,
     /*source*/ harnessSources,
-    /*prereqs*/ [builtLocalDirectory, tscFile].concat(libraryTargets).concat(servicesSources).concat(harnessSources),
-    /*prefixes*/ [],
+    /*prereqs*/[builtLocalDirectory, tscFile].concat(libraryTargets).concat(servicesSources).concat(harnessSources),
+    /*prefixes*/[],
     /*useBuiltCompiler:*/ true,
     /*opts*/ { inlineSourceMap: true, types: ["node", "mocha", "chai"] });
 
@@ -694,22 +732,22 @@ desc("Builds the test infrastructure using the built compiler");
 task("tests", ["local", run].concat(libraryTargets));
 
 function exec(cmd, completeHandler, errorHandler) {
-    var ex = jake.createExec([cmd], {windowsVerbatimArguments: true});
+    var ex = jake.createExec([cmd], { windowsVerbatimArguments: true });
     // Add listeners for output and error
-    ex.addListener("stdout", function(output) {
+    ex.addListener("stdout", function (output) {
         process.stdout.write(output);
     });
-    ex.addListener("stderr", function(error) {
+    ex.addListener("stderr", function (error) {
         process.stderr.write(error);
     });
-    ex.addListener("cmdEnd", function() {
+    ex.addListener("cmdEnd", function () {
         if (completeHandler) {
             completeHandler();
         }
         complete();
     });
-    ex.addListener("error", function(e, status) {
-        if(errorHandler) {
+    ex.addListener("error", function (e, status) {
+        if (errorHandler) {
             errorHandler(e, status);
         } else {
             fail("Process exited with code " + status);
@@ -797,7 +835,8 @@ function runConsoleTests(defaultReporter, runInParallel) {
 
     // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally
     // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer
-    if(!runInParallel) {
+    if (!runInParallel) {
+        var startTime = mark();
         tests = tests ? ' -g "' + tests + '"' : '';
         var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + bail + ' -t ' + testTimeout + ' ' + run;
         console.log(cmd);
@@ -806,10 +845,12 @@ function runConsoleTests(defaultReporter, runInParallel) {
         process.env.NODE_ENV = "development";
         exec(cmd, function () {
             process.env.NODE_ENV = savedNodeEnv;
+            measure(startTime);
             runLinter();
             finish();
-        }, function(e, status) {
+        }, function (e, status) {
             process.env.NODE_ENV = savedNodeEnv;
+            measure(startTime);
             finish(status);
         });
 
@@ -817,9 +858,10 @@ function runConsoleTests(defaultReporter, runInParallel) {
     else {
         var savedNodeEnv = process.env.NODE_ENV;
         process.env.NODE_ENV = "development";
+        var startTime = mark();
         runTestsInParallel(taskConfigsFolder, run, { testTimeout: testTimeout, noColors: colors === " --no-colors " }, function (err) {
             process.env.NODE_ENV = savedNodeEnv;
-
+            measure(startTime);
             // last worker clean everything and runs linter in case if there were no errors
             deleteTemporaryProjectOutput();
             jake.rmRf(taskConfigsFolder);
@@ -860,14 +902,14 @@ function runConsoleTests(defaultReporter, runInParallel) {
 
 var testTimeout = 20000;
 desc("Runs all the tests in parallel using the built run.js file. Optional arguments are: t[ests]=category1|category2|... d[ebug]=true.");
-task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], function() {
+task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], function () {
     runConsoleTests('min', /*runInParallel*/ true);
-}, {async: true});
+}, { async: true });
 
 desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true bail=false dirty=false.");
 task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
     runConsoleTests('mocha-fivemat-progress-reporter', /*runInParallel*/ false);
-}, {async: true});
+}, { async: true });
 
 desc("Generates code coverage data via instanbul");
 task("generate-code-coverage", ["tests", builtLocalDirectory], function () {
@@ -885,20 +927,20 @@ desc("Runs browserify on run.js to produce a file suitable for running tests in
 task("browserify", ["tests", builtLocalDirectory, nodeServerOutFile], function() {
     var cmd = 'browserify built/local/run.js -t ./scripts/browserify-optional -d -o built/local/bundle.js';
     exec(cmd);
-}, {async: true});
+}, { async: true });
 
 desc("Runs the tests using the built run.js file like 'jake runtests'. Syntax is jake runtests-browser. Additional optional parameters tests=[regex], browser=[chrome|IE]");
-task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFileInBrowserTest], function() {
+task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFileInBrowserTest], function () {
     cleanTestDirs();
     host = "node";
     browser = process.env.browser || process.env.b || "IE";
     tests = process.env.test || process.env.tests || process.env.t;
     var light = process.env.light || false;
     var testConfigFile = 'test.config';
-    if(fs.existsSync(testConfigFile)) {
+    if (fs.existsSync(testConfigFile)) {
         fs.unlinkSync(testConfigFile);
     }
-    if(tests || light) {
+    if (tests || light) {
         writeTestConfigFile(tests, light);
     }
 
@@ -906,7 +948,7 @@ task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFi
     var cmd = host + " tests/webTestServer.js " + browser + " " + JSON.stringify(tests);
     console.log(cmd);
     exec(cmd);
-}, {async: true});
+}, { async: true });
 
 function getDiffTool() {
     var program = process.env['DIFF'];
@@ -919,17 +961,17 @@ function getDiffTool() {
 // Baseline Diff
 desc("Diffs the compiler baselines using the diff tool specified by the 'DIFF' environment variable");
 task('diff', function () {
-    var cmd = '"' +  getDiffTool()  + '" ' + refBaseline + ' ' + localBaseline;
+    var cmd = '"' + getDiffTool() + '" ' + refBaseline + ' ' + localBaseline;
     console.log(cmd);
     exec(cmd);
-}, {async: true});
+}, { async: true });
 
 desc("Diffs the RWC baselines using the diff tool specified by the 'DIFF' environment variable");
 task('diff-rwc', function () {
-    var cmd = '"' +  getDiffTool()  + '" ' + refRwcBaseline + ' ' + localRwcBaseline;
+    var cmd = '"' + getDiffTool() + '" ' + refRwcBaseline + ' ' + localRwcBaseline;
     console.log(cmd);
     exec(cmd);
-}, {async: true});
+}, { async: true });
 
 desc("Builds the test sources and automation in debug mode");
 task("tests-debug", ["setDebugMode", "tests"]);
@@ -937,30 +979,39 @@ task("tests-debug", ["setDebugMode", "tests"]);
 
 // Makes the test results the new baseline
 desc("Makes the most recent test results the new baseline, overwriting the old baseline");
-task("baseline-accept", function(hardOrSoft) {
-    if (!hardOrSoft || hardOrSoft === "hard") {
-        jake.rmRf(refBaseline);
-        fs.renameSync(localBaseline, refBaseline);
-    }
-    else if (hardOrSoft === "soft") {
-        var files = jake.readdirR(localBaseline);
-        for (var i in files) {
-            jake.cpR(files[i], refBaseline);
+task("baseline-accept", function () {
+    acceptBaseline("");
+});
+
+function acceptBaseline(containerFolder) {
+    var sourceFolder = path.join(localBaseline, containerFolder);
+    var targetFolder = path.join(refBaseline, containerFolder);
+    console.log('Accept baselines from ' + sourceFolder + ' to ' + targetFolder);
+    var files = fs.readdirSync(sourceFolder);
+    var deleteEnding = '.delete';
+    for (var i in files) {
+        var filename = files[i];
+        if (filename.substr(filename.length - deleteEnding.length) === deleteEnding) {
+            filename = filename.substr(0, filename.length - deleteEnding.length);
+            fs.unlinkSync(path.join(targetFolder, filename));
+        } else {
+            var target = path.join(targetFolder, filename);
+            if (fs.existsSync(target)) {
+                fs.unlinkSync(target);
+            }
+            fs.renameSync(path.join(sourceFolder, filename), target);
         }
-        jake.rmRf(path.join(refBaseline, "local"));
     }
-});
+}
 
 desc("Makes the most recent rwc test results the new baseline, overwriting the old baseline");
-task("baseline-accept-rwc", function() {
-    jake.rmRf(refRwcBaseline);
-    fs.renameSync(localRwcBaseline, refRwcBaseline);
+task("baseline-accept-rwc", function () {
+    acceptBaseline("rwc");
 });
 
 desc("Makes the most recent test262 test results the new baseline, overwriting the old baseline");
-task("baseline-accept-test262", function() {
-    jake.rmRf(refTest262Baseline);
-    fs.renameSync(localTest262Baseline, refTest262Baseline);
+task("baseline-accept-test262", function () {
+    acceptBaseline("test262");
 });
 
 
@@ -970,8 +1021,8 @@ var webhostJsPath = "tests/webhost/webtsc.js";
 compileFile(webhostJsPath, [webhostPath], [tscFile, webhostPath].concat(libraryTargets), [], /*useBuiltCompiler*/true);
 
 desc("Builds the tsc web host");
-task("webhost", [webhostJsPath], function() {
-    jake.cpR(path.join(builtLocalDirectory, "lib.d.ts"), "tests/webhost/", {silent: true});
+task("webhost", [webhostJsPath], function () {
+    jake.cpR(path.join(builtLocalDirectory, "lib.d.ts"), "tests/webhost/", { silent: true });
 });
 
 // Perf compiler
@@ -984,38 +1035,38 @@ task("perftsc", [perftscJsPath]);
 // Instrumented compiler
 var loggedIOpath = harnessDirectory + 'loggedIO.ts';
 var loggedIOJsPath = builtLocalDirectory + 'loggedIO.js';
-file(loggedIOJsPath, [builtLocalDirectory, loggedIOpath], function() {
+file(loggedIOJsPath, [builtLocalDirectory, loggedIOpath], function () {
     var temp = builtLocalDirectory + 'temp';
     jake.mkdirP(temp);
     var options = "--outdir " + temp + ' ' + loggedIOpath;
     var cmd = host + " " + LKGDirectory + compilerFilename + " " + options + " ";
     console.log(cmd + "\n");
     var ex = jake.createExec([cmd]);
-    ex.addListener("cmdEnd", function() {
+    ex.addListener("cmdEnd", function () {
         fs.renameSync(temp + '/harness/loggedIO.js', loggedIOJsPath);
         jake.rmRf(temp);
         complete();
     });
     ex.run();
-}, {async: true});
+}, { async: true });
 
 var instrumenterPath = harnessDirectory + 'instrumenter.ts';
 var instrumenterJsPath = builtLocalDirectory + 'instrumenter.js';
 compileFile(instrumenterJsPath, [instrumenterPath], [tscFile, instrumenterPath].concat(libraryTargets), [], /*useBuiltCompiler*/ true);
 
 desc("Builds an instrumented tsc.js");
-task('tsc-instrumented', [loggedIOJsPath, instrumenterJsPath, tscFile], function() {
+task('tsc-instrumented', [loggedIOJsPath, instrumenterJsPath, tscFile], function () {
     var cmd = host + ' ' + instrumenterJsPath + ' record iocapture ' + builtLocalDirectory + compilerFilename;
     console.log(cmd);
     var ex = jake.createExec([cmd]);
-    ex.addListener("cmdEnd", function() {
+    ex.addListener("cmdEnd", function () {
         complete();
     });
     ex.run();
 }, { async: true });
 
 desc("Updates the sublime plugin's tsserver");
-task("update-sublime", ["local", serverFile], function() {
+task("update-sublime", ["local", serverFile], function () {
     jake.cpR(serverFile, "../TypeScript-Sublime-Plugin/tsserver/");
     jake.cpR(serverFile + ".map", "../TypeScript-Sublime-Plugin/tsserver/");
 });
@@ -1031,124 +1082,111 @@ var tslintRules = [
     "objectLiteralSurroundingSpaceRule",
     "noTypeAssertionWhitespaceRule"
 ];
-var tslintRulesFiles = tslintRules.map(function(p) {
+var tslintRulesFiles = tslintRules.map(function (p) {
     return path.join(tslintRuleDir, p + ".ts");
 });
-var tslintRulesOutFiles = tslintRules.map(function(p) {
+var tslintRulesOutFiles = tslintRules.map(function (p) {
     return path.join(builtLocalDirectory, "tslint", p + ".js");
 });
 desc("Compiles tslint rules to js");
-task("build-rules", tslintRulesOutFiles);
-tslintRulesFiles.forEach(function(ruleFile, i) {
+task("build-rules", ["build-rules-start"].concat(tslintRulesOutFiles).concat(["build-rules-end"]));
+tslintRulesFiles.forEach(function (ruleFile, i) {
     compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false,
-    { noOutFile: true, generateDeclarations: false, outDir: path.join(builtLocalDirectory, "tslint")});
+        { noOutFile: true, generateDeclarations: false, outDir: path.join(builtLocalDirectory, "tslint") });
 });
 
-function getLinterOptions() {
-    return {
-        configuration: require("./tslint.json"),
-        formatter: "prose",
-        formattersDirectory: undefined,
-        rulesDirectory: "built/local/tslint"
-    };
-}
-
-function lintFileContents(options, path, contents) {
-    var ll = new Linter(path, contents, options);
-    console.log("Linting '" + path + "'.");
-    return ll.lint();
-}
-
-function lintFile(options, path) {
-    var contents = fs.readFileSync(path, "utf8");
-    return lintFileContents(options, path, contents);
-}
+desc("Emit the start of the build-rules fold");
+task("build-rules-start", [], function () {
+    if (fold.isTravis()) console.log(fold.start("build-rules"));
+});
 
-function lintFileAsync(options, path, cb) {
-    fs.readFile(path, "utf8", function(err, contents) {
-        if (err) {
-            return cb(err);
-        }
-        var result = lintFileContents(options, path, contents);
-        cb(undefined, result);
-    });
-}
+desc("Emit the end of the build-rules fold");
+task("build-rules-end", [], function () {
+    if (fold.isTravis()) console.log(fold.end("build-rules"));
+});
 
 var lintTargets = compilerSources
     .concat(harnessSources)
     // Other harness sources
-    .concat(["instrumenter.ts"].map(function(f) { return path.join(harnessDirectory, f) }))
+    .concat(["instrumenter.ts"].map(function (f) { return path.join(harnessDirectory, f) }))
     .concat(serverCoreSources)
     .concat(tslintRulesFiles)
     .concat(servicesSources)
     .concat(["Gulpfile.ts"])
     .concat([nodeServerInFile, perftscPath, "tests/perfsys.ts", webhostPath]);
 
+function sendNextFile(files, child, callback, failures) {
+    var file = files.pop();
+    if (file) {
+        console.log("Linting '" + file + "'.");
+        child.send({ kind: "file", name: file });
+    }
+    else {
+        child.send({ kind: "close" });
+        callback(failures);
+    }
+}
+
+function spawnLintWorker(files, callback) {
+    var child = child_process.fork("./scripts/parallel-lint");
+    var failures = 0;
+    child.on("message", function (data) {
+        switch (data.kind) {
+            case "result":
+                if (data.failures > 0) {
+                    failures += data.failures;
+                    console.log(data.output);
+                }
+                sendNextFile(files, child, callback, failures);
+                break;
+            case "error":
+                console.error(data.error);
+                failures++;
+                sendNextFile(files, child, callback, failures);
+                break;
+        }
+    });
+    sendNextFile(files, child, callback, failures);
+}
 
 desc("Runs tslint on the compiler sources. Optional arguments are: f[iles]=regex");
-task("lint", ["build-rules"], function() {
-    var lintOptions = getLinterOptions();
+task("lint", ["build-rules"], function () {
+    if (fold.isTravis()) console.log(fold.start("lint"));
+    var startTime = mark();
     var failed = 0;
     var fileMatcher = RegExp(process.env.f || process.env.file || process.env.files || "");
     var done = {};
     for (var i in lintTargets) {
         var target = lintTargets[i];
         if (!done[target] && fileMatcher.test(target)) {
-            var result = lintFile(lintOptions, target);
-            if (result.failureCount > 0) {
-                console.log(result.output);
-                failed += result.failureCount;
-            }
-            done[target] = true;
+            done[target] = fs.statSync(target).size;
         }
     }
-    if (failed > 0) {
-        fail('Linter errors.', failed);
-    }
-});
 
-/**
- * This is required because file watches on Windows get fires _twice_
- * when a file changes on some node/windows version configuations
- * (node v4 and win 10, for example). By not running a lint for a file
- * which already has a pending lint, we avoid duplicating our work.
- * (And avoid printing duplicate results!)
- */
-var lintSemaphores = {};
-
-function lintWatchFile(filename) {
-    fs.watch(filename, {persistent: true}, function(event) {
-        if (event !== "change") {
-            return;
-        }
+    var workerCount = (process.env.workerCount && +process.env.workerCount) || os.cpus().length;
 
-        if (!lintSemaphores[filename]) {
-            lintSemaphores[filename] = true;
-            lintFileAsync(getLinterOptions(), filename, function(err, result) {
-                delete lintSemaphores[filename];
-                if (err) {
-                    console.log(err);
-                    return;
-                }
-                if (result.failureCount > 0) {
-                    console.log("***Lint failure***");
-                    for (var i = 0; i < result.failures.length; i++) {
-                        var failure = result.failures[i];
-                        var start = failure.startPosition.lineAndCharacter;
-                        var end = failure.endPosition.lineAndCharacter;
-                        console.log("warning " + filename + " (" + (start.line + 1) + "," + (start.character + 1) + "," + (end.line + 1) + "," + (end.character + 1) + "): " + failure.failure);
-                    }
-                    console.log("*** Total " + result.failureCount + " failures.");
-                }
-            });
-        }
+    var names = Object.keys(done).sort(function (namea, nameb) {
+        return done[namea] - done[nameb];
     });
-}
 
-desc("Watches files for changes to rerun a lint pass");
-task("lint-server", ["build-rules"], function() {
-    console.log("Watching ./src for changes to linted files");
-    for (var i = 0; i < lintTargets.length; i++) {
-        lintWatchFile(lintTargets[i]);
+    for (var i = 0; i < workerCount; i++) {
+        spawnLintWorker(names, finished);
     }
-});
+
+    var completed = 0;
+    var failures = 0;
+    function finished(fails) {
+        completed++;
+        failures += fails;
+        if (completed === workerCount) {
+            measure(startTime);
+            if (fold.isTravis()) console.log(fold.end("lint"));
+            if (failures > 0) {
+                fail('Linter errors.', failed);
+            }
+            else {
+                complete();
+            }
+        }
+    }
+}, { async: true });
diff --git a/README.md b/README.md
index fca2890bc7783..d16bc363b269e 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 
 [![Join the chat at https://gitter.im/Microsoft/TypeScript](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/Microsoft/TypeScript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-[TypeScript](http://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types, classes, and modules to JavaScript. TypeScript supports tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](http://www.typescriptlang.org/Playground), and stay up to date via [our blog](http://blogs.msdn.com/typescript) and [Twitter account](https://twitter.com/typescriptlang).
+[TypeScript](http://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types, classes, and modules to JavaScript. TypeScript supports tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](http://www.typescriptlang.org/Playground), and stay up to date via [our blog](https://blogs.msdn.microsoft.com/typescript) and [Twitter account](https://twitter.com/typescriptlang).
 
 ## Installing
 
diff --git a/package.json b/package.json
index efe3866b6dbc0..1f943f89788d6 100644
--- a/package.json
+++ b/package.json
@@ -30,8 +30,8 @@
     },
     "devDependencies": {
         "@types/browserify": "latest",
-        "@types/convert-source-map": "latest",
         "@types/chai": "latest",
+        "@types/convert-source-map": "latest",
         "@types/del": "latest",
         "@types/glob": "latest",
         "@types/gulp": "latest",
@@ -69,9 +69,11 @@
         "mkdirp": "latest",
         "mocha": "latest",
         "mocha-fivemat-progress-reporter": "latest",
+        "q": "latest",
         "run-sequence": "latest",
         "sorcery": "latest",
         "through2": "latest",
+        "travis-fold": "latest",
         "ts-node": "latest",
         "tsd": "latest",
         "tslint": "next",
@@ -79,7 +81,7 @@
     },
     "scripts": {
         "pretest": "jake tests",
-        "test": "jake runtests",
+        "test": "jake runtests-parallel",
         "build": "npm run build:compiler && npm run build:tests",
         "build:compiler": "jake local",
         "build:tests": "jake tests",
diff --git a/scripts/ior.ts b/scripts/ior.ts
index eb67e62a275cf..91580203350f5 100644
--- a/scripts/ior.ts
+++ b/scripts/ior.ts
@@ -1,4 +1,4 @@
-/// <reference path="../src/harness/external/node.d.ts" />
+/// <reference types="node"/>
 
 import fs = require('fs');
 import path = require('path');
diff --git a/scripts/parallel-lint.js b/scripts/parallel-lint.js
new file mode 100644
index 0000000000000..a9aec06c2dfa0
--- /dev/null
+++ b/scripts/parallel-lint.js
@@ -0,0 +1,45 @@
+var Linter = require("tslint");
+var fs = require("fs");
+
+function getLinterOptions() {
+    return {
+        configuration: require("../tslint.json"),
+        formatter: "prose",
+        formattersDirectory: undefined,
+        rulesDirectory: "built/local/tslint"
+    };
+}
+
+function lintFileContents(options, path, contents) {
+    var ll = new Linter(path, contents, options);
+    return ll.lint();
+}
+
+function lintFileAsync(options, path, cb) {
+    fs.readFile(path, "utf8", function (err, contents) {
+        if (err) {
+            return cb(err);
+        }
+        var result = lintFileContents(options, path, contents);
+        cb(undefined, result);
+    });
+}
+
+process.on("message", function (data) {
+    switch (data.kind) {
+        case "file":
+            var target = data.name;
+            var lintOptions = getLinterOptions();
+            lintFileAsync(lintOptions, target, function (err, result) {
+                if (err) {
+                    process.send({ kind: "error", error: err.toString() });
+                    return;
+                }
+                process.send({ kind: "result", failures: result.failureCount, output: result.output });
+            });
+            break;
+        case "close":
+            process.exit(0);
+            break;
+    }
+});
\ No newline at end of file
diff --git a/scripts/processDiagnosticMessages.ts b/scripts/processDiagnosticMessages.ts
index 26632ba6bab3c..431cf46018050 100644
--- a/scripts/processDiagnosticMessages.ts
+++ b/scripts/processDiagnosticMessages.ts
@@ -69,7 +69,7 @@ function checkForUniqueCodes(messages: string[], diagnosticTable: InputDiagnosti
 }
 
 function buildUniqueNameMap(names: string[]): ts.Map<string> {
-    var nameMap: ts.Map<string> = {};
+    var nameMap = ts.createMap<string>();
 
     var uniqueNames = NameGenerator.ensureUniqueness(names, /* isCaseSensitive */ false, /* isFixed */ undefined);
 
diff --git a/scripts/tslint/preferConstRule.ts b/scripts/tslint/preferConstRule.ts
index aaa1b0e53d5b8..1d3166924686a 100644
--- a/scripts/tslint/preferConstRule.ts
+++ b/scripts/tslint/preferConstRule.ts
@@ -1,7 +1,6 @@
 import * as Lint from "tslint/lib/lint";
 import * as ts from "typescript";
 
-
 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.`;
 
@@ -64,7 +63,7 @@ interface DeclarationUsages {
 }
 
 class PreferConstWalker extends Lint.RuleWalker {
-    private inScopeLetDeclarations: ts.Map<DeclarationUsages>[] = [];
+    private inScopeLetDeclarations: ts.MapLike<DeclarationUsages>[] = [];
     private errors: Lint.RuleFailure[] = [];
     private markAssignment(identifier: ts.Identifier) {
         const name = identifier.text;
@@ -172,7 +171,7 @@ class PreferConstWalker extends Lint.RuleWalker {
     }
 
     private visitAnyForStatement(node: ts.ForOfStatement | ts.ForInStatement) {
-        const names: ts.Map<DeclarationUsages> = {};
+        const names: ts.MapLike<DeclarationUsages> = {};
         if (isLet(node.initializer)) {
             if (node.initializer.kind === ts.SyntaxKind.VariableDeclarationList) {
                 this.collectLetIdentifiers(node.initializer as ts.VariableDeclarationList, names);
@@ -194,7 +193,7 @@ class PreferConstWalker extends Lint.RuleWalker {
     }
 
     visitBlock(node: ts.Block) {
-        const names: ts.Map<DeclarationUsages> = {};
+        const names: ts.MapLike<DeclarationUsages> = {};
         for (const statement of node.statements) {
             if (statement.kind === ts.SyntaxKind.VariableStatement) {
                 this.collectLetIdentifiers((statement as ts.VariableStatement).declarationList, names);
@@ -205,7 +204,7 @@ class PreferConstWalker extends Lint.RuleWalker {
         this.popDeclarations();
     }
 
-    private collectLetIdentifiers(list: ts.VariableDeclarationList, ret: ts.Map<DeclarationUsages>) {
+    private collectLetIdentifiers(list: ts.VariableDeclarationList, ret: ts.MapLike<DeclarationUsages>) {
         for (const node of list.declarations) {
             if (isLet(node) && !isExported(node)) {
                 this.collectNameIdentifiers(node, node.name, ret);
@@ -213,7 +212,7 @@ class PreferConstWalker extends Lint.RuleWalker {
         }
     }
 
-    private collectNameIdentifiers(declaration: ts.VariableDeclaration, node: ts.Identifier | ts.BindingPattern, table: ts.Map<DeclarationUsages>) {
+    private collectNameIdentifiers(declaration: ts.VariableDeclaration, node: ts.Identifier | ts.BindingPattern, table: ts.MapLike<DeclarationUsages>) {
         if (node.kind === ts.SyntaxKind.Identifier) {
             table[(node as ts.Identifier).text] = { declaration, usages: 0 };
         }
@@ -222,7 +221,7 @@ class PreferConstWalker extends Lint.RuleWalker {
         }
     }
 
-    private collectBindingPatternIdentifiers(value: ts.VariableDeclaration, pattern: ts.BindingPattern, table: ts.Map<DeclarationUsages>) {
+    private collectBindingPatternIdentifiers(value: ts.VariableDeclaration, pattern: ts.BindingPattern, table: ts.MapLike<DeclarationUsages>) {
         for (const element of pattern.elements) {
             this.collectNameIdentifiers(value, element.name, table);
         }
diff --git a/scripts/types/ambient.d.ts b/scripts/types/ambient.d.ts
index e77e3fe8c5a6d..4f4b118c432db 100644
--- a/scripts/types/ambient.d.ts
+++ b/scripts/types/ambient.d.ts
@@ -10,7 +10,7 @@ declare module "gulp-insert" {
     export function append(text: string | Buffer): NodeJS.ReadWriteStream;
     export function prepend(text: string | Buffer): NodeJS.ReadWriteStream;
     export function wrap(text: string | Buffer, tail: string | Buffer): NodeJS.ReadWriteStream;
-    export function transform(cb: (contents: string, file: {path: string}) => string): NodeJS.ReadWriteStream; // file is a vinyl file
+    export function transform(cb: (contents: string, file: {path: string, relative: string}) => string): NodeJS.ReadWriteStream; // file is a vinyl file
 }
 
 declare module "into-stream" {
@@ -22,3 +22,4 @@ declare module "into-stream" {
 }
 
 declare module "sorcery";
+declare module "travis-fold";
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index cf3142a3241e6..50c3adf13107a 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -89,9 +89,10 @@ namespace ts {
     const binder = createBinder();
 
     export function bindSourceFile(file: SourceFile, options: CompilerOptions) {
-        const start = performance.mark();
+        performance.mark("beforeBind");
         binder(file, options);
-        performance.measure("Bind", start);
+        performance.mark("afterBind");
+        performance.measure("Bind", "beforeBind", "afterBind");
     }
 
     function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
@@ -139,7 +140,7 @@ namespace ts {
             options = opts;
             languageVersion = getEmitScriptTarget(options);
             inStrictMode = !!file.externalModuleIndicator;
-            classifiableNames = {};
+            classifiableNames = createMap<string>();
             symbolCount = 0;
             skipTransformFlagAggregation = isDeclarationFile(file);
 
@@ -189,11 +190,11 @@ namespace ts {
             symbol.declarations.push(node);
 
             if (symbolFlags & SymbolFlags.HasExports && !symbol.exports) {
-                symbol.exports = {};
+                symbol.exports = createMap<Symbol>();
             }
 
             if (symbolFlags & SymbolFlags.HasMembers && !symbol.members) {
-                symbol.members = {};
+                symbol.members = createMap<Symbol>();
             }
 
             if (symbolFlags & SymbolFlags.Value) {
@@ -304,8 +305,10 @@ namespace ts {
             const name = isDefaultExport && parent ? "default" : getDeclarationName(node);
 
             let symbol: Symbol;
-            if (name !== undefined) {
-
+            if (name === undefined) {
+                symbol = createSymbol(SymbolFlags.None, "__missing");
+            }
+            else {
                 // Check and see if the symbol table already has a symbol with this name.  If not,
                 // create a new symbol with this name and add it to the table.  Note that we don't
                 // give the new symbol any flags *yet*.  This ensures that it will not conflict
@@ -317,6 +320,11 @@ namespace ts {
                 // declaration we have for this symbol, and then create a new symbol for this
                 // declaration.
                 //
+                // Note that when properties declared in Javascript constructors
+                // (marked by isReplaceableByMethod) conflict with another symbol, the property loses.
+                // Always. This allows the common Javascript pattern of overwriting a prototype method
+                // with an bound instance method of the same type: `this.method = this.method.bind(this)`
+                //
                 // If we created a new symbol, either because we didn't have a symbol with this name
                 // in the symbol table, or we conflicted with an existing symbol, then just add this
                 // node as the sole declaration of the new symbol.
@@ -324,42 +332,44 @@ namespace ts {
                 // Otherwise, we'll be merging into a compatible existing symbol (for example when
                 // you have multiple 'vars' with the same name in the same container).  In this case
                 // just add this node into the declarations list of the symbol.
-                symbol = hasProperty(symbolTable, name)
-                    ? symbolTable[name]
-                    : (symbolTable[name] = createSymbol(SymbolFlags.None, name));
+                symbol = symbolTable[name] || (symbolTable[name] = createSymbol(SymbolFlags.None, name));
 
                 if (name && (includes & SymbolFlags.Classifiable)) {
                     classifiableNames[name] = name;
                 }
 
                 if (symbol.flags & excludes) {
-                    if (node.name) {
-                        node.name.parent = node;
+                    if (symbol.isReplaceableByMethod) {
+                        // Javascript constructor-declared symbols can be discarded in favor of
+                        // prototype symbols like methods.
+                        symbol = symbolTable[name] = createSymbol(SymbolFlags.None, name);
                     }
+                    else {
+                        if (node.name) {
+                            node.name.parent = node;
+                        }
 
-                    // Report errors every position with duplicate declaration
-                    // Report errors on previous encountered declarations
-                    let message = symbol.flags & SymbolFlags.BlockScopedVariable
-                        ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
-                        : Diagnostics.Duplicate_identifier_0;
+                        // Report errors every position with duplicate declaration
+                        // Report errors on previous encountered declarations
+                        let message = symbol.flags & SymbolFlags.BlockScopedVariable
+                            ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
+                            : Diagnostics.Duplicate_identifier_0;
 
-                    forEach(symbol.declarations, declaration => {
-                        if (hasModifier(declaration, ModifierFlags.Default)) {
-                            message = Diagnostics.A_module_cannot_have_multiple_default_exports;
-                        }
-                    });
+                        forEach(symbol.declarations, declaration => {
+                            if (hasModifier(declaration, ModifierFlags.Default)) {
+                                message = Diagnostics.A_module_cannot_have_multiple_default_exports;
+                            }
+                        });
 
-                    forEach(symbol.declarations, declaration => {
-                        file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
-                    });
-                    file.bindDiagnostics.push(createDiagnosticForNode(node.name || node, message, getDisplayName(node)));
+                        forEach(symbol.declarations, declaration => {
+                            file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
+                        });
+                        file.bindDiagnostics.push(createDiagnosticForNode(node.name || node, message, getDisplayName(node)));
 
-                    symbol = createSymbol(SymbolFlags.None, name);
+                        symbol = createSymbol(SymbolFlags.None, name);
+                    }
                 }
             }
-            else {
-                symbol = createSymbol(SymbolFlags.None, "__missing");
-            }
 
             addDeclarationToSymbol(symbol, node, includes);
             symbol.parent = parent;
@@ -440,7 +450,7 @@ namespace ts {
             if (containerFlags & ContainerFlags.IsContainer) {
                 container = blockScopeContainer = node;
                 if (containerFlags & ContainerFlags.HasLocals) {
-                    container.locals = {};
+                    container.locals = createMap<Symbol>();
                 }
                 addToContainerChain(container);
             }
@@ -1422,7 +1432,8 @@ namespace ts {
 
             const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
             addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);
-            typeLiteralSymbol.members = { [symbol.name]: symbol };
+            typeLiteralSymbol.members = createMap<Symbol>();
+            typeLiteralSymbol.members[symbol.name] = symbol;
         }
 
         function bindObjectLiteralExpression(node: ObjectLiteralExpression) {
@@ -1432,7 +1443,7 @@ namespace ts {
             }
 
             if (inStrictMode) {
-                const seen: Map<ElementKind> = {};
+                const seen = createMap<ElementKind>();
 
                 for (const prop of node.properties) {
                     if (prop.name.kind !== SyntaxKind.Identifier) {
@@ -1488,7 +1499,7 @@ namespace ts {
                 // fall through.
                 default:
                     if (!blockScopeContainer.locals) {
-                        blockScopeContainer.locals = {};
+                        blockScopeContainer.locals = createMap<Symbol>();
                         addToContainerChain(blockScopeContainer);
                     }
                     declareSymbol(blockScopeContainer.locals, undefined, node, symbolFlags, symbolExcludes);
@@ -1913,18 +1924,17 @@ namespace ts {
         }
 
         function bindExportAssignment(node: ExportAssignment | BinaryExpression) {
-            const boundExpression = node.kind === SyntaxKind.ExportAssignment ? (<ExportAssignment>node).expression : (<BinaryExpression>node).right;
             if (!container.symbol || !container.symbol.exports) {
                 // Export assignment in some sort of block construct
                 bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
             }
-            else if (boundExpression.kind === SyntaxKind.Identifier && node.kind === SyntaxKind.ExportAssignment) {
-                // An export default clause with an identifier exports all meanings of that identifier
-                declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
-            }
             else {
-                // An export default clause with an expression exports a value
-                declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
+                const flags = node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node)
+                    // An export default clause with an EntityNameExpression exports all meanings of that identifier
+                    ? SymbolFlags.Alias
+                    // An export default clause with any other expression exports a value
+                    : SymbolFlags.Property;
+                declareSymbol(container.symbol.exports, container.symbol, node, flags, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
             }
         }
 
@@ -1951,7 +1961,7 @@ namespace ts {
                 }
             }
 
-            file.symbol.globalExports = file.symbol.globalExports || {};
+            file.symbol.globalExports = file.symbol.globalExports || createMap<Symbol>();
             declareSymbol(file.symbol.globalExports, file.symbol, node, SymbolFlags.Alias, SymbolFlags.AliasExcludes);
         }
 
@@ -1993,20 +2003,25 @@ namespace ts {
         }
 
         function bindThisPropertyAssignment(node: BinaryExpression) {
-            // Declare a 'member' in case it turns out the container was an ES5 class or ES6 constructor
-            let assignee: Node;
+            Debug.assert(isInJavaScriptFile(node));
+            // Declare a 'member' if the container is an ES5 class or ES6 constructor
             if (container.kind === SyntaxKind.FunctionDeclaration || container.kind === SyntaxKind.FunctionExpression) {
-                assignee = container;
+                container.symbol.members = container.symbol.members || createMap<Symbol>();
+                // It's acceptable for multiple 'this' assignments of the same identifier to occur
+                declareSymbol(container.symbol.members, container.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
             }
             else if (container.kind === SyntaxKind.Constructor) {
-                assignee = container.parent;
-            }
-            else {
-                return;
+                // this.foo assignment in a JavaScript class
+                // Bind this property to the containing class
+                const saveContainer = container;
+                container = container.parent;
+                const symbol = bindPropertyOrMethodOrAccessor(node, SymbolFlags.Property, SymbolFlags.None);
+                if (symbol) {
+                    // constructor-declared symbols can be overwritten by subsequent method declarations
+                    (symbol as Symbol).isReplaceableByMethod = true;
+                }
+                container = saveContainer;
             }
-            assignee.symbol.members = assignee.symbol.members || {};
-            // It's acceptable for multiple 'this' assignments of the same identifier to occur
-            declareSymbol(assignee.symbol.members, assignee.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
         }
 
         function bindPrototypePropertyAssignment(node: BinaryExpression) {
@@ -2030,7 +2045,7 @@ namespace ts {
 
             // Set up the members collection if it doesn't exist already
             if (!funcSymbol.members) {
-                funcSymbol.members = {};
+                funcSymbol.members = createMap<Symbol>();
             }
 
             // Declare the method/property
@@ -2079,7 +2094,7 @@ namespace ts {
             // 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.
             const prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
-            if (hasProperty(symbol.exports, prototypeSymbol.name)) {
+            if (symbol.exports[prototypeSymbol.name]) {
                 if (node.name) {
                     node.name.parent = node;
                 }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 0a5173efece29..81f22e2f1921d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -44,7 +44,7 @@ namespace ts {
         let symbolCount = 0;
 
         const emptyArray: any[] = [];
-        const emptySymbols: SymbolTable = {};
+        const emptySymbols = createMap<Symbol>();
 
         const compilerOptions = host.getCompilerOptions();
         const languageVersion = compilerOptions.target || ScriptTarget.ES3;
@@ -106,11 +106,11 @@ namespace ts {
             isOptionalParameter
         };
 
-        const tupleTypes: Map<TupleType> = {};
-        const unionTypes: Map<UnionType> = {};
-        const intersectionTypes: Map<IntersectionType> = {};
-        const stringLiteralTypes: Map<LiteralType> = {};
-        const numericLiteralTypes: Map<LiteralType> = {};
+        const tupleTypes: GenericType[] = [];
+        const unionTypes = createMap<UnionType>();
+        const intersectionTypes = createMap<IntersectionType>();
+        const stringLiteralTypes = createMap<LiteralType>();
+        const numericLiteralTypes = createMap<LiteralType>();
 
         const unknownSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "unknown");
         const resolvingSymbol = createSymbol(SymbolFlags.Transient, "__resolving__");
@@ -132,7 +132,7 @@ namespace ts {
 
         const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         const emptyGenericType = <GenericType><ObjectType>createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
-        emptyGenericType.instantiations = {};
+        emptyGenericType.instantiations = createMap<TypeReference>();
 
         const anyFunctionType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated
@@ -146,7 +146,7 @@ namespace ts {
 
         const enumNumberIndexInfo = createIndexInfo(stringType, /*isReadonly*/ true);
 
-        const globals: SymbolTable = {};
+        const globals = createMap<Symbol>();
         /**
          * List of every ambient module with a "*" wildcard.
          * Unlike other ambient modules, these can't be stored in `globals` because symbol tables only deal with exact matches.
@@ -246,7 +246,8 @@ namespace ts {
             NEUndefinedOrNull = 1 << 19,  // x != undefined / x != null
             Truthy = 1 << 20,             // x
             Falsy = 1 << 21,              // !x
-            All = (1 << 22) - 1,
+            Discriminatable = 1 << 22,    // May have discriminant property
+            All = (1 << 23) - 1,
             // The following members encode facts about particular kinds of types for use in the getTypeFacts function.
             // The presence of a particular fact means that the given test is true for some (and possibly all) values
             // of that kind of type.
@@ -276,15 +277,15 @@ namespace ts {
             TrueFacts = BaseBooleanFacts | Truthy,
             SymbolStrictFacts = TypeofEQSymbol | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
             SymbolFacts = SymbolStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
-            ObjectStrictFacts = TypeofEQObject | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
+            ObjectStrictFacts = TypeofEQObject | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | NEUndefined | NENull | NEUndefinedOrNull | Truthy | Discriminatable,
             ObjectFacts = ObjectStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
-            FunctionStrictFacts = TypeofEQFunction | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy,
+            FunctionStrictFacts = TypeofEQFunction | TypeofEQHostObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | NEUndefined | NENull | NEUndefinedOrNull | Truthy | Discriminatable,
             FunctionFacts = FunctionStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
             UndefinedFacts = TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | EQUndefined | EQUndefinedOrNull | NENull | Falsy,
             NullFacts = TypeofEQObject | TypeofNEString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEFunction | TypeofNEHostObject | EQNull | EQUndefinedOrNull | NEUndefined | Falsy,
         }
 
-        const typeofEQFacts: Map<TypeFacts> = {
+        const typeofEQFacts = createMap({
             "string": TypeFacts.TypeofEQString,
             "number": TypeFacts.TypeofEQNumber,
             "boolean": TypeFacts.TypeofEQBoolean,
@@ -292,9 +293,9 @@ namespace ts {
             "undefined": TypeFacts.EQUndefined,
             "object": TypeFacts.TypeofEQObject,
             "function": TypeFacts.TypeofEQFunction
-        };
+        });
 
-        const typeofNEFacts: Map<TypeFacts> = {
+        const typeofNEFacts = createMap({
             "string": TypeFacts.TypeofNEString,
             "number": TypeFacts.TypeofNENumber,
             "boolean": TypeFacts.TypeofNEBoolean,
@@ -302,19 +303,19 @@ namespace ts {
             "undefined": TypeFacts.NEUndefined,
             "object": TypeFacts.TypeofNEObject,
             "function": TypeFacts.TypeofNEFunction
-        };
+        });
 
-        const typeofTypesByName: Map<Type> = {
+        const typeofTypesByName = createMap<Type>({
             "string": stringType,
             "number": numberType,
             "boolean": booleanType,
             "symbol": esSymbolType,
             "undefined": undefinedType
-        };
+        });
 
         let jsxElementType: ObjectType;
         /** Things we lazy load from the JSX namespace */
-        const jsxTypes: Map<ObjectType> = {};
+        const jsxTypes = createMap<ObjectType>();
         const JsxNames = {
             JSX: "JSX",
             IntrinsicElements: "IntrinsicElements",
@@ -325,10 +326,10 @@ namespace ts {
             IntrinsicClassAttributes: "IntrinsicClassAttributes"
         };
 
-        const subtypeRelation: Map<RelationComparisonResult> = {};
-        const assignableRelation: Map<RelationComparisonResult> = {};
-        const comparableRelation: Map<RelationComparisonResult> = {};
-        const identityRelation: Map<RelationComparisonResult> = {};
+        const subtypeRelation = createMap<RelationComparisonResult>();
+        const assignableRelation = createMap<RelationComparisonResult>();
+        const comparableRelation = createMap<RelationComparisonResult>();
+        const identityRelation = createMap<RelationComparisonResult>();
 
         // This is for caching the result of getSymbolDisplayBuilder. Do not access directly.
         let _displayBuilder: SymbolDisplayBuilder;
@@ -342,9 +343,8 @@ namespace ts {
             ResolvedReturnType
         }
 
-        const builtinGlobals: SymbolTable = {
-            [undefinedSymbol.name]: undefinedSymbol
-        };
+        const builtinGlobals = createMap<Symbol>();
+        builtinGlobals[undefinedSymbol.name] = undefinedSymbol;
 
         initializeTypeChecker();
 
@@ -404,8 +404,8 @@ namespace ts {
             result.parent = symbol.parent;
             if (symbol.valueDeclaration) result.valueDeclaration = symbol.valueDeclaration;
             if (symbol.constEnumOnlyModule) result.constEnumOnlyModule = true;
-            if (symbol.members) result.members = cloneSymbolTable(symbol.members);
-            if (symbol.exports) result.exports = cloneSymbolTable(symbol.exports);
+            if (symbol.members) result.members = cloneMap(symbol.members);
+            if (symbol.exports) result.exports = cloneMap(symbol.exports);
             recordMergedSymbol(result, symbol);
             return result;
         }
@@ -427,11 +427,11 @@ namespace ts {
                     target.declarations.push(node);
                 });
                 if (source.members) {
-                    if (!target.members) target.members = {};
+                    if (!target.members) target.members = createMap<Symbol>();
                     mergeSymbolTable(target.members, source.members);
                 }
                 if (source.exports) {
-                    if (!target.exports) target.exports = {};
+                    if (!target.exports) target.exports = createMap<Symbol>();
                     mergeSymbolTable(target.exports, source.exports);
                 }
                 recordMergedSymbol(target, source);
@@ -448,29 +448,17 @@ namespace ts {
             }
         }
 
-        function cloneSymbolTable(symbolTable: SymbolTable): SymbolTable {
-            const result: SymbolTable = {};
-            for (const id in symbolTable) {
-                if (hasProperty(symbolTable, id)) {
-                    result[id] = symbolTable[id];
-                }
-            }
-            return result;
-        }
-
         function mergeSymbolTable(target: SymbolTable, source: SymbolTable) {
             for (const id in source) {
-                if (hasProperty(source, id)) {
-                    if (!hasProperty(target, id)) {
-                        target[id] = source[id];
-                    }
-                    else {
-                        let symbol = target[id];
-                        if (!(symbol.flags & SymbolFlags.Merged)) {
-                            target[id] = symbol = cloneSymbol(symbol);
-                        }
-                        mergeSymbol(symbol, source[id]);
+                let targetSymbol = target[id];
+                if (!targetSymbol) {
+                    target[id] = source[id];
+                }
+                else {
+                    if (!(targetSymbol.flags & SymbolFlags.Merged)) {
+                        target[id] = targetSymbol = cloneSymbol(targetSymbol);
                     }
+                    mergeSymbol(targetSymbol, source[id]);
                 }
             }
         }
@@ -514,14 +502,12 @@ namespace ts {
 
         function addToSymbolTable(target: SymbolTable, source: SymbolTable, message: DiagnosticMessage) {
             for (const id in source) {
-                if (hasProperty(source, id)) {
-                    if (hasProperty(target, id)) {
-                        // Error on redeclarations
-                        forEach(target[id].declarations, addDeclarationDiagnostic(id, message));
-                    }
-                    else {
-                        target[id] = source[id];
-                    }
+                if (target[id]) {
+                    // Error on redeclarations
+                    forEach(target[id].declarations, addDeclarationDiagnostic(id, message));
+                }
+                else {
+                    target[id] = source[id];
                 }
             }
 
@@ -538,7 +524,7 @@ namespace ts {
 
         function getNodeLinks(node: Node): NodeLinks {
             const nodeId = getNodeId(node);
-            return nodeLinks[nodeId] || (nodeLinks[nodeId] = {});
+            return nodeLinks[nodeId] || (nodeLinks[nodeId] = { flags: 0 });
         }
 
         function isGlobalSourceFile(node: Node) {
@@ -546,18 +532,20 @@ namespace ts {
         }
 
         function getSymbol(symbols: SymbolTable, name: string, meaning: SymbolFlags): Symbol {
-            if (meaning && hasProperty(symbols, name)) {
+            if (meaning) {
                 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) {
-                    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) {
+                if (symbol) {
+                    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) {
+                        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;
+                        }
+                    }
                 }
             }
             // return undefined if we can't find a symbol.
@@ -665,7 +653,7 @@ namespace ts {
         // Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
         // the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
         // the given name can be found.
-        function resolveName(location: Node, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
+        function resolveName(location: Node | undefined, name: string, meaning: SymbolFlags, nameNotFoundMessage: DiagnosticMessage, nameArg: string | Identifier): Symbol {
             let result: Symbol;
             let lastLocation: Node;
             let propertyWithInvalidInitializer: Node;
@@ -745,7 +733,7 @@ namespace ts {
                             //     2. We check === SymbolFlags.Alias in order to check that the symbol is *purely*
                             //        an alias. If we used &, we'd be throwing out symbols that have non alias aspects,
                             //        which is not the desired behavior.
-                            if (hasProperty(moduleExports, name) &&
+                            if (moduleExports[name] &&
                                 moduleExports[name].flags === SymbolFlags.Alias &&
                                 getDeclarationOfKind(moduleExports[name], SyntaxKind.ExportSpecifier)) {
                                 break;
@@ -882,7 +870,8 @@ namespace ts {
 
             if (!result) {
                 if (nameNotFoundMessage) {
-                    if (!checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
+                    if (!errorLocation ||
+                        !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) &&
                         !checkAndReportErrorForExtendingInterface(errorLocation)) {
                         error(errorLocation, nameNotFoundMessage, typeof nameArg === "string" ? nameArg : declarationNameToString(nameArg));
                     }
@@ -931,7 +920,7 @@ namespace ts {
         }
 
         function checkAndReportErrorForMissingPrefix(errorLocation: Node, name: string, nameArg: string | Identifier): boolean {
-            if (!errorLocation || (errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
+            if ((errorLocation.kind === SyntaxKind.Identifier && (isTypeReferenceIdentifier(<Identifier>errorLocation)) || isInTypeQuery(errorLocation))) {
                 return false;
             }
 
@@ -969,29 +958,31 @@ namespace ts {
 
 
         function checkAndReportErrorForExtendingInterface(errorLocation: Node): boolean {
-            let parentClassExpression = errorLocation;
-            while (parentClassExpression) {
-                const kind = parentClassExpression.kind;
-                if (kind === SyntaxKind.Identifier || kind === SyntaxKind.PropertyAccessExpression) {
-                    parentClassExpression = parentClassExpression.parent;
-                    continue;
-                }
-                if (kind === SyntaxKind.ExpressionWithTypeArguments) {
-                    break;
-                }
-                return false;
-            }
-            if (!parentClassExpression) {
-                return false;
-            }
-            const expression = (<ExpressionWithTypeArguments>parentClassExpression).expression;
-            if (resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true)) {
+            const expression = getEntityNameForExtendingInterface(errorLocation);
+            const isError = !!(expression && resolveEntityName(expression, SymbolFlags.Interface, /*ignoreErrors*/ true));
+            if (isError) {
                 error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
-                return true;
             }
-            return false;
+            return isError;
+        }
+        /**
+         * Climbs up parents to an ExpressionWithTypeArguments, and returns its expression,
+         * but returns undefined if that expression is not an EntityNameExpression.
+         */
+        function getEntityNameForExtendingInterface(node: Node): EntityNameExpression | undefined {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                case SyntaxKind.PropertyAccessExpression:
+                    return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
+                case SyntaxKind.ExpressionWithTypeArguments:
+                    Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
+                default:
+                    return undefined;
+            }
         }
 
+
         function checkResolvedBlockScopedVariable(result: Symbol, errorLocation: Node): void {
             Debug.assert((result.flags & SymbolFlags.BlockScopedVariable) !== 0);
             // Block-scoped variables cannot be used before their definition
@@ -1034,7 +1025,7 @@ namespace ts {
         }
 
         function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
-            return forEach(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
+            return findMap(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
         }
 
         function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
@@ -1102,9 +1093,9 @@ namespace ts {
 
         function getExportOfModule(symbol: Symbol, name: string): Symbol {
             if (symbol.flags & SymbolFlags.Module) {
-                const exports = getExportsOfSymbol(symbol);
-                if (hasProperty(exports, name)) {
-                    return resolveSymbol(exports[name]);
+                const exportedSymbol = getExportsOfSymbol(symbol)[name];
+                if (exportedSymbol) {
+                    return resolveSymbol(exportedSymbol);
                 }
             }
         }
@@ -1136,13 +1127,13 @@ namespace ts {
                     else {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);
                     }
-                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
-                    if (!symbolFromVariable && allowSyntheticDefaultImports && name.text === "default") {
-                        symbolFromVariable = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
-                    }
                     // if symbolFromVariable is export - get its final target
                     symbolFromVariable = resolveSymbol(symbolFromVariable);
-                    const symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    let symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
+                    if (!symbolFromModule && allowSyntheticDefaultImports && name.text === "default") {
+                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                    }
                     const symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
                         symbolFromModule || symbolFromVariable;
@@ -1169,7 +1160,7 @@ namespace ts {
         }
 
         function getTargetOfExportAssignment(node: ExportAssignment): Symbol {
-            return resolveEntityName(<Identifier>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
+            return resolveEntityName(<EntityNameExpression>node.expression, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace);
         }
 
         function getTargetOfAliasDeclaration(node: Declaration): Symbol {
@@ -1279,7 +1270,7 @@ namespace ts {
         }
 
         // Resolves a qualified name and any involved aliases
-        function resolveEntityName(name: EntityName | Expression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean, location?: Node): Symbol {
+        function resolveEntityName(name: EntityNameOrEntityNameExpression, meaning: SymbolFlags, ignoreErrors?: boolean, dontResolveAlias?: boolean, location?: Node): Symbol | undefined {
             if (nodeIsMissing(name)) {
                 return undefined;
             }
@@ -1294,7 +1285,7 @@ namespace ts {
                 }
             }
             else if (name.kind === SyntaxKind.QualifiedName || name.kind === SyntaxKind.PropertyAccessExpression) {
-                const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessExpression>name).expression;
+                const left = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).left : (<PropertyAccessEntityNameExpression>name).expression;
                 const right = name.kind === SyntaxKind.QualifiedName ? (<QualifiedName>name).right : (<PropertyAccessExpression>name).name;
 
                 const namespace = resolveEntityName(left, SymbolFlags.Namespace, ignoreErrors, /*dontResolveAlias*/ false, location);
@@ -1374,7 +1365,14 @@ namespace ts {
 
             if (moduleNotFoundError) {
                 // report errors only if it was requested
-                error(errorNode, moduleNotFoundError, moduleName);
+                const tsExtension = tryExtractTypeScriptExtension(moduleName);
+                if (tsExtension) {
+                    const diag = Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
+                    error(errorNode, diag, tsExtension, removeExtension(moduleName, tsExtension));
+                }
+                else {
+                    error(errorNode, moduleNotFoundError, moduleName);
+                }
             }
             return undefined;
         }
@@ -1425,7 +1423,7 @@ namespace ts {
          */
         function extendExportSymbols(target: SymbolTable, source: SymbolTable, lookupTable?: Map<ExportCollisionTracker>, exportNode?: ExportDeclaration) {
             for (const id in source) {
-                if (id !== "default" && !hasProperty(target, id)) {
+                if (id !== "default" && !target[id]) {
                     target[id] = source[id];
                     if (lookupTable && exportNode) {
                         lookupTable[id] = {
@@ -1433,7 +1431,7 @@ namespace ts {
                         } as ExportCollisionTracker;
                     }
                 }
-                else if (lookupTable && exportNode && id !== "default" && hasProperty(target, id) && resolveSymbol(target[id]) !== resolveSymbol(source[id])) {
+                else if (lookupTable && exportNode && id !== "default" && target[id] && resolveSymbol(target[id]) !== resolveSymbol(source[id])) {
                     if (!lookupTable[id].exportsWithDuplicate) {
                         lookupTable[id].exportsWithDuplicate = [exportNode];
                     }
@@ -1455,12 +1453,12 @@ namespace ts {
                     return;
                 }
                 visitedSymbols.push(symbol);
-                const symbols = cloneSymbolTable(symbol.exports);
+                const symbols = cloneMap(symbol.exports);
                 // All export * declarations are collected in an __export symbol by the binder
                 const exportStars = symbol.exports["__export"];
                 if (exportStars) {
-                    const nestedSymbols: SymbolTable = {};
-                    const lookupTable: Map<ExportCollisionTracker> = {};
+                    const nestedSymbols = createMap<Symbol>();
+                    const lookupTable = createMap<ExportCollisionTracker>();
                     for (const node of exportStars.declarations) {
                         const resolvedModule = resolveExternalModuleName(node, (node as ExportDeclaration).moduleSpecifier);
                         const exportedSymbols = visit(resolvedModule);
@@ -1474,7 +1472,7 @@ namespace ts {
                     for (const id in lookupTable) {
                         const { exportsWithDuplicate } = lookupTable[id];
                         // It's not an error if the file with multiple `export *`s with duplicate names exports a member with that name itself
-                        if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || hasProperty(symbols, id)) {
+                        if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols[id]) {
                             continue;
                         }
                         for (const node of exportsWithDuplicate) {
@@ -1542,8 +1540,8 @@ namespace ts {
 
         function createType(flags: TypeFlags): Type {
             const result = new Type(checker, flags);
-            result.id = typeCount;
             typeCount++;
+            result.id = typeCount;
             return result;
         }
 
@@ -1580,13 +1578,11 @@ namespace ts {
         function getNamedMembers(members: SymbolTable): Symbol[] {
             let result: Symbol[];
             for (const id in members) {
-                if (hasProperty(members, id)) {
-                    if (!isReservedMemberName(id)) {
-                        if (!result) result = [];
-                        const symbol = members[id];
-                        if (symbolIsValue(symbol)) {
-                            result.push(symbol);
-                        }
+                if (!isReservedMemberName(id)) {
+                    if (!result) result = [];
+                    const symbol = members[id];
+                    if (symbolIsValue(symbol)) {
+                        result.push(symbol);
                     }
                 }
             }
@@ -1662,12 +1658,12 @@ namespace ts {
                 }
 
                 // If symbol is directly available by its name in the symbol table
-                if (isAccessible(lookUp(symbols, symbol.name))) {
+                if (isAccessible(symbols[symbol.name])) {
                     return [symbol];
                 }
 
                 // Check if symbol is any of the alias
-                return forEachValue(symbols, symbolFromSymbolTable => {
+                return forEachProperty(symbols, symbolFromSymbolTable => {
                     if (symbolFromSymbolTable.flags & SymbolFlags.Alias
                         && symbolFromSymbolTable.name !== "export="
                         && !getDeclarationOfKind(symbolFromSymbolTable, SyntaxKind.ExportSpecifier)) {
@@ -1702,12 +1698,12 @@ namespace ts {
             let qualify = false;
             forEachSymbolTableInScope(enclosingDeclaration, symbolTable => {
                 // If symbol of this name is not available in the symbol table we are ok
-                if (!hasProperty(symbolTable, symbol.name)) {
+                let symbolFromSymbolTable = symbolTable[symbol.name];
+                if (!symbolFromSymbolTable) {
                     // Continue to the next symbol table
                     return false;
                 }
                 // If the symbol with this name is present it should refer to the symbol
-                let symbolFromSymbolTable = symbolTable[symbol.name];
                 if (symbolFromSymbolTable === symbol) {
                     // No need to qualify
                     return true;
@@ -1853,7 +1849,7 @@ namespace ts {
             }
         }
 
-        function isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult {
+        function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
             // get symbol of the first identifier of the entityName
             let meaning: SymbolFlags;
             if (entityName.parent.kind === SyntaxKind.TypeQuery || isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) {
@@ -2153,9 +2149,6 @@ namespace ts {
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, nextFlags);
                     }
-                    else if (type.flags & TypeFlags.Tuple) {
-                        writeTupleType(<TupleType>type);
-                    }
                     else if (!(flags & TypeFormatFlags.InTypeAlias) && type.flags & (TypeFlags.Anonymous | TypeFlags.UnionOrIntersection) && type.aliasSymbol) {
                         const typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, typeArguments ? typeArguments.length : 0, nextFlags);
@@ -2222,6 +2215,11 @@ namespace ts {
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
+                    else if (type.target.flags & TypeFlags.Tuple) {
+                        writePunctuation(writer, SyntaxKind.OpenBracketToken);
+                        writeTypeList(type.typeArguments.slice(0, getTypeReferenceArity(type)), SyntaxKind.CommaToken);
+                        writePunctuation(writer, SyntaxKind.CloseBracketToken);
+                    }
                     else {
                         // 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
@@ -2250,12 +2248,6 @@ namespace ts {
                     }
                 }
 
-                function writeTupleType(type: TupleType) {
-                    writePunctuation(writer, SyntaxKind.OpenBracketToken);
-                    writeTypeList(type.elementTypes, SyntaxKind.CommaToken);
-                    writePunctuation(writer, SyntaxKind.CloseBracketToken);
-                }
-
                 function writeUnionOrIntersectionType(type: UnionOrIntersectionType, flags: TypeFormatFlags) {
                     if (flags & TypeFormatFlags.InElementType) {
                         writePunctuation(writer, SyntaxKind.OpenParenToken);
@@ -2966,7 +2958,7 @@ namespace ts {
                         : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
-                            error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), (<TupleType>parentType).elementTypes.length, pattern.elements.length);
+                            error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), getTypeReferenceArity(<TypeReference>parentType), pattern.elements.length);
                         }
                         else {
                             error(declaration, Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName);
@@ -3078,9 +3070,14 @@ namespace ts {
                     }
                 }
                 // Use contextual parameter type if one is available
-                const type = declaration.symbol.name === "this"
-                    ? getContextuallyTypedThisType(func)
-                    : getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                let type: Type;
+                if (declaration.symbol.name === "this") {
+                    const thisParameter = getContextualThisParameter(func);
+                    type = thisParameter ? getTypeOfSymbol(thisParameter) : undefined;
+                }
+                else {
+                    type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                }
                 if (type) {
                     return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
                 }
@@ -3098,7 +3095,7 @@ namespace ts {
 
             // If the declaration specifies a binding pattern, use the type implied by the binding pattern
             if (isBindingPattern(declaration.name)) {
-                return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ false);
+                return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ false, /*reportErrors*/ true);
             }
 
             // No type specified and nothing can be inferred
@@ -3108,24 +3105,22 @@ namespace ts {
         // Return the type implied by a binding pattern element. This is the type of the initializer of the element if
         // one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding
         // pattern. Otherwise, it is the type any.
-        function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean): Type {
+        function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean, reportErrors?: boolean): Type {
             if (element.initializer) {
-                const type = checkExpressionCached(element.initializer);
-                reportErrorsFromWidening(element, type);
-                return getWidenedType(type);
+                return checkExpressionCached(element.initializer);
             }
             if (isBindingPattern(element.name)) {
-                return getTypeFromBindingPattern(<BindingPattern>element.name, includePatternInType);
+                return getTypeFromBindingPattern(<BindingPattern>element.name, includePatternInType, reportErrors);
             }
-            if (compilerOptions.noImplicitAny && !declarationBelongsToPrivateAmbientMember(element)) {
+            if (reportErrors && compilerOptions.noImplicitAny && !declarationBelongsToPrivateAmbientMember(element)) {
                 reportImplicitAnyError(element, anyType);
             }
             return anyType;
         }
 
         // Return the type implied by an object binding pattern
-        function getTypeFromObjectBindingPattern(pattern: BindingPattern, includePatternInType: boolean): Type {
-            const members: SymbolTable = {};
+        function getTypeFromObjectBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
+            const members = createMap<Symbol>();
             let hasComputedProperties = false;
             forEach(pattern.elements, e => {
                 const name = e.propertyName || <Identifier>e.name;
@@ -3138,7 +3133,7 @@ namespace ts {
                 const text = getTextOfPropertyName(name);
                 const flags = SymbolFlags.Property | SymbolFlags.Transient | (e.initializer ? SymbolFlags.Optional : 0);
                 const symbol = <TransientSymbol>createSymbol(flags, text);
-                symbol.type = getTypeFromBindingElement(e, includePatternInType);
+                symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors);
                 symbol.bindingElement = e;
                 members[symbol.name] = symbol;
             });
@@ -3153,19 +3148,19 @@ namespace ts {
         }
 
         // Return the type implied by an array binding pattern
-        function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean): Type {
+        function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
             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.
-            const 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, reportErrors));
+            let result = createTupleType(elementTypes);
             if (includePatternInType) {
-                const result = createNewTupleType(elementTypes);
+                result = cloneTypeReference(result);
                 result.pattern = pattern;
-                return result;
             }
-            return createTupleType(elementTypes);
+            return result;
         }
 
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
@@ -3175,10 +3170,10 @@ namespace ts {
         // used as the contextual type of an initializer associated with the binding pattern. Also, for a destructuring
         // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of
         // the parameter.
-        function getTypeFromBindingPattern(pattern: BindingPattern, includePatternInType?: boolean): Type {
+        function getTypeFromBindingPattern(pattern: BindingPattern, includePatternInType?: boolean, reportErrors?: boolean): Type {
             return pattern.kind === SyntaxKind.ObjectBindingPattern
-                ? getTypeFromObjectBindingPattern(pattern, includePatternInType)
-                : getTypeFromArrayBindingPattern(pattern, includePatternInType);
+                ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors)
+                : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors);
         }
 
         // Return the type associated with a variable, parameter, or property declaration. In the simple case this is the type
@@ -3255,6 +3250,13 @@ namespace ts {
                 // * className.prototype.method = expr
                 if (declaration.kind === SyntaxKind.BinaryExpression ||
                     declaration.kind === SyntaxKind.PropertyAccessExpression && declaration.parent.kind === SyntaxKind.BinaryExpression) {
+                    // Use JS Doc type if present on parent expression statement
+                    if (declaration.flags & NodeFlags.JavaScriptFile) {
+                        const typeTag = getJSDocTypeTag(declaration.parent);
+                        if (typeTag && typeTag.typeExpression) {
+                            return links.type = getTypeFromTypeNode(typeTag.typeExpression.type);
+                        }
+                    }
                     const declaredTypes = map(symbol.declarations,
                         decl => decl.kind === SyntaxKind.BinaryExpression ?
                             checkExpressionCached((<BinaryExpression>decl).right) :
@@ -3567,17 +3569,20 @@ namespace ts {
         }
 
         function getBaseTypes(type: InterfaceType): ObjectType[] {
-            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");
+                if (type.flags & TypeFlags.Tuple) {
+                    type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
                 }
-                if (isClass) {
-                    resolveBaseTypesOfClass(type);
+                else if (type.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                    if (type.symbol.flags & SymbolFlags.Class) {
+                        resolveBaseTypesOfClass(type);
+                    }
+                    if (type.symbol.flags & SymbolFlags.Interface) {
+                        resolveBaseTypesOfInterface(type);
+                    }
                 }
-                if (isInterface) {
-                    resolveBaseTypesOfInterface(type);
+                else {
+                    Debug.fail("type must be class or interface");
                 }
             }
             return type.resolvedBaseTypes;
@@ -3683,7 +3688,7 @@ namespace ts {
                     const baseTypeNodes = getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration);
                     if (baseTypeNodes) {
                         for (const node of baseTypeNodes) {
-                            if (isSupportedExpressionWithTypeArguments(node)) {
+                            if (isEntityNameExpression(node.expression)) {
                                 const baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true);
                                 if (!baseSymbol || !(baseSymbol.flags & SymbolFlags.Interface) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
                                     return false;
@@ -3713,7 +3718,7 @@ namespace ts {
                     type.typeParameters = concatenate(outerTypeParameters, localTypeParameters);
                     type.outerTypeParameters = outerTypeParameters;
                     type.localTypeParameters = localTypeParameters;
-                    (<GenericType>type).instantiations = {};
+                    (<GenericType>type).instantiations = createMap<TypeReference>();
                     (<GenericType>type).instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
                     (<GenericType>type).target = <GenericType>type;
                     (<GenericType>type).typeArguments = type.typeParameters;
@@ -3755,7 +3760,7 @@ namespace ts {
                     if (typeParameters) {
                         // Initialize the instantiation cache for generic type aliases. The declared type corresponds to
                         // an instantiation of the type alias with the type parameters supplied as type arguments.
-                        links.instantiations = {};
+                        links.instantiations = createMap<Type>();
                         links.instantiations[getTypeListId(links.typeParameters)] = type;
                     }
                 }
@@ -3776,7 +3781,7 @@ namespace ts {
             return expr.kind === SyntaxKind.NumericLiteral ||
                 expr.kind === SyntaxKind.PrefixUnaryExpression && (<PrefixUnaryExpression>expr).operator === SyntaxKind.MinusToken &&
                 (<PrefixUnaryExpression>expr).operand.kind === SyntaxKind.NumericLiteral ||
-                expr.kind === SyntaxKind.Identifier && hasProperty(symbol.exports, (<Identifier>expr).text);
+                expr.kind === SyntaxKind.Identifier && !!symbol.exports[(<Identifier>expr).text];
         }
 
         function enumHasLiteralMembers(symbol: Symbol) {
@@ -3799,7 +3804,7 @@ namespace ts {
                 enumType.symbol = symbol;
                 if (enumHasLiteralMembers(symbol)) {
                     const memberTypeList: Type[] = [];
-                    const memberTypes: Map<EnumLiteralType> = {};
+                    const memberTypes = createMap<EnumLiteralType>();
                     for (const declaration of enumType.symbol.declarations) {
                         if (declaration.kind === SyntaxKind.EnumDeclaration) {
                             computeEnumMemberValues(<EnumDeclaration>declaration);
@@ -3962,7 +3967,7 @@ namespace ts {
         }
 
         function createSymbolTable(symbols: Symbol[]): SymbolTable {
-            const result: SymbolTable = {};
+            const result = createMap<Symbol>();
             for (const symbol of symbols) {
                 result[symbol.name] = symbol;
             }
@@ -3972,7 +3977,7 @@ 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 {
-            const result: SymbolTable = {};
+            const result = createMap<Symbol>();
             for (const symbol of symbols) {
                 result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper);
             }
@@ -3981,7 +3986,7 @@ namespace ts {
 
         function addInheritedMembers(symbols: SymbolTable, baseSymbols: Symbol[]) {
             for (const s of baseSymbols) {
-                if (!hasProperty(symbols, s.name)) {
+                if (!symbols[s.name]) {
                     symbols[s.name] = s;
                 }
             }
@@ -4008,13 +4013,21 @@ namespace ts {
         }
 
         function resolveObjectTypeMembers(type: ObjectType, source: InterfaceTypeWithDeclaredMembers, typeParameters: TypeParameter[], typeArguments: Type[]) {
-            let mapper = identityMapper;
-            let members = source.symbol.members;
-            let callSignatures = source.declaredCallSignatures;
-            let constructSignatures = source.declaredConstructSignatures;
-            let stringIndexInfo = source.declaredStringIndexInfo;
-            let numberIndexInfo = source.declaredNumberIndexInfo;
-            if (!rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+            let mapper: TypeMapper;
+            let members: SymbolTable;
+            let callSignatures: Signature[];
+            let constructSignatures: Signature[];
+            let stringIndexInfo: IndexInfo;
+            let numberIndexInfo: IndexInfo;
+            if (rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+                mapper = identityMapper;
+                members = source.symbol ? source.symbol.members : createSymbolTable(source.declaredProperties);
+                callSignatures = source.declaredCallSignatures;
+                constructSignatures = source.declaredConstructSignatures;
+                stringIndexInfo = source.declaredStringIndexInfo;
+                numberIndexInfo = source.declaredNumberIndexInfo;
+            }
+            else {
                 mapper = createTypeMapper(typeParameters, typeArguments);
                 members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
                 callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
@@ -4024,7 +4037,7 @@ namespace ts {
             }
             const baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
-                if (members === source.symbol.members) {
+                if (source.symbol && members === source.symbol.members) {
                     members = createSymbolTable(source.declaredProperties);
                 }
                 const thisArgument = lastOrUndefined(typeArguments);
@@ -4094,25 +4107,6 @@ namespace ts {
             return result;
         }
 
-        function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
-            const members: SymbolTable = {};
-            for (let i = 0; i < memberTypes.length; i++) {
-                const symbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
-                symbol.type = memberTypes[i];
-                members[i] = symbol;
-            }
-            return members;
-        }
-
-        function resolveTupleTypeMembers(type: TupleType) {
-            const arrayElementType = getUnionType(type.elementTypes);
-            // Make the tuple type itself the 'this' type by including an extra type argument
-            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type]));
-            const members = createTupleTypeMemberSymbols(type.elementTypes);
-            addInheritedMembers(members, arrayType.properties);
-            setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
-        }
-
         function findMatchingSignature(signatureList: Signature[], signature: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean): Signature {
             for (const s of signatureList) {
                 if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypesIdentical)) {
@@ -4291,9 +4285,6 @@ namespace ts {
                 else if (type.flags & TypeFlags.Anonymous) {
                     resolveAnonymousTypeMembers(<AnonymousType>type);
                 }
-                else if (type.flags & TypeFlags.Tuple) {
-                    resolveTupleTypeMembers(<TupleType>type);
-                }
                 else if (type.flags & TypeFlags.Union) {
                     resolveUnionTypeMembers(<UnionType>type);
                 }
@@ -4317,11 +4308,9 @@ namespace ts {
         function getPropertyOfObjectType(type: Type, name: string): Symbol {
             if (type.flags & TypeFlags.ObjectType) {
                 const resolved = resolveStructuredTypeMembers(<ObjectType>type);
-                if (hasProperty(resolved.members, name)) {
-                    const symbol = resolved.members[name];
-                    if (symbolIsValue(symbol)) {
-                        return symbol;
-                    }
+                const symbol = resolved.members[name];
+                if (symbol && symbolIsValue(symbol)) {
+                    return symbol;
                 }
             }
         }
@@ -4420,10 +4409,19 @@ namespace ts {
             }
             const propTypes: Type[] = [];
             const declarations: Declaration[] = [];
+            let commonType: Type = undefined;
+            let hasCommonType = true;
             for (const prop of props) {
                 if (prop.declarations) {
                     addRange(declarations, prop.declarations);
                 }
+                const type = getTypeOfSymbol(prop);
+                if (!commonType) {
+                    commonType = type;
+                }
+                else if (type !== commonType) {
+                    hasCommonType = false;
+                }
                 propTypes.push(getTypeOfSymbol(prop));
             }
             const result = <TransientSymbol>createSymbol(
@@ -4433,6 +4431,7 @@ namespace ts {
                 commonFlags,
                 name);
             result.containingType = containingType;
+            result.hasCommonType = hasCommonType;
             result.declarations = declarations;
             result.isReadonly = isReadonly;
             result.type = containingType.flags & TypeFlags.Union ? getUnionType(propTypes) : getIntersectionType(propTypes);
@@ -4440,29 +4439,32 @@ namespace ts {
         }
 
         function getPropertyOfUnionOrIntersectionType(type: UnionOrIntersectionType, name: string): Symbol {
-            const properties = type.resolvedProperties || (type.resolvedProperties = {});
-            if (hasProperty(properties, name)) {
-                return properties[name];
-            }
-            const property = createUnionOrIntersectionProperty(type, name);
-            if (property) {
-                properties[name] = property;
+            const properties = type.resolvedProperties || (type.resolvedProperties = createMap<Symbol>());
+            let property = properties[name];
+            if (!property) {
+                property = createUnionOrIntersectionProperty(type, name);
+                if (property) {
+                    properties[name] = property;
+                }
             }
             return property;
         }
 
-        // Return the symbol for the property with the given name in the given type. Creates synthetic union properties when
-        // necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from
-        // Object and Function as appropriate.
+        /**
+         * Return the symbol for the property with the given name in the given type. Creates synthetic union properties when
+         * necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from
+         * Object and Function as appropriate.
+         *
+         * @param type a type to look up property from
+         * @param name a name of property to look up in a given type
+         */
         function getPropertyOfType(type: Type, name: string): Symbol {
             type = getApparentType(type);
             if (type.flags & TypeFlags.ObjectType) {
                 const resolved = resolveStructuredTypeMembers(type);
-                if (hasProperty(resolved.members, name)) {
-                    const symbol = resolved.members[name];
-                    if (symbolIsValue(symbol)) {
-                        return symbol;
-                    }
+                const symbol = resolved.members[name];
+                if (symbol && symbolIsValue(symbol)) {
+                    return symbol;
                 }
                 if (resolved === anyFunctionType || resolved.callSignatures.length || resolved.constructSignatures.length) {
                     const symbol = getPropertyOfObjectType(globalFunctionType, name);
@@ -4682,6 +4684,9 @@ namespace ts {
                 if (isJSConstructSignature) {
                     minArgumentCount--;
                 }
+                if (!thisParameter && isObjectLiteralMethod(declaration)) {
+                    thisParameter = getContextualThisParameter(declaration);
+                }
 
                 const classType = declaration.kind === SyntaxKind.Constructor ?
                     getDeclaredTypeOfClassOrInterface(getMergedSymbol((<ClassDeclaration>declaration.parent).symbol))
@@ -4930,24 +4935,27 @@ namespace ts {
         }
 
         function getTypeListId(types: Type[]) {
+            let result = "";
             if (types) {
-                switch (types.length) {
-                    case 1:
-                        return "" + types[0].id;
-                    case 2:
-                        return types[0].id + "," + types[1].id;
-                    default:
-                        let result = "";
-                        for (let i = 0; i < types.length; i++) {
-                            if (i > 0) {
-                                result += ",";
-                            }
-                            result += types[i].id;
-                        }
-                        return result;
+                const length = types.length;
+                let i = 0;
+                while (i < length) {
+                    const startId = types[i].id;
+                    let count = 1;
+                    while (i + count < length && types[i + count].id === startId + count) {
+                        count++;
+                    }
+                    if (result.length) {
+                        result += ",";
+                    }
+                    result += startId;
+                    if (count > 1) {
+                        result += ":" + count;
+                    }
+                    i += count;
                 }
             }
-            return "";
+            return result;
         }
 
         // This function is used to propagate certain flags when creating new object type references and union types.
@@ -4977,6 +4985,17 @@ namespace ts {
             return type;
         }
 
+        function cloneTypeReference(source: TypeReference): TypeReference {
+            const type = <TypeReference>createObjectType(source.flags, source.symbol);
+            type.target = source.target;
+            type.typeArguments = source.typeArguments;
+            return type;
+        }
+
+        function getTypeReferenceArity(type: TypeReference): number {
+            return type.target.typeParameters ? type.target.typeParameters.length : 0;
+        }
+
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference, symbol: Symbol): Type {
             const type = <InterfaceType>getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
@@ -5030,7 +5049,7 @@ namespace ts {
             return getDeclaredTypeOfSymbol(symbol);
         }
 
-        function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): LeftHandSideExpression | EntityName {
+        function getTypeReferenceName(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference): EntityNameOrEntityNameExpression | undefined {
             switch (node.kind) {
                 case SyntaxKind.TypeReference:
                     return (<TypeReferenceNode>node).typeName;
@@ -5039,8 +5058,9 @@ namespace ts {
                 case SyntaxKind.ExpressionWithTypeArguments:
                     // We only support expressions that are simple qualified names. For other
                     // expressions this produces undefined.
-                    if (isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node)) {
-                        return (<ExpressionWithTypeArguments>node).expression;
+                    const expr = (<ExpressionWithTypeArguments>node).expression;
+                    if (isEntityNameExpression(expr)) {
+                        return expr;
                     }
 
                 // fall through;
@@ -5051,7 +5071,7 @@ namespace ts {
 
         function resolveTypeReferenceName(
             node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference,
-            typeReferenceName: LeftHandSideExpression | EntityName) {
+            typeReferenceName: EntityNameExpression | EntityName) {
 
             if (!typeReferenceName) {
                 return unknownSymbol;
@@ -5092,15 +5112,14 @@ namespace ts {
                     const typeReferenceName = getTypeReferenceName(node);
                     symbol = resolveTypeReferenceName(node, typeReferenceName);
                     type = getTypeReferenceType(node, symbol);
-
-                    links.resolvedSymbol = symbol;
-                    links.resolvedType = type;
                 }
                 else {
                     // We only support expressions that are simple qualified names. For other expressions this produces undefined.
-                    const typeNameOrExpression = node.kind === SyntaxKind.TypeReference ? (<TypeReferenceNode>node).typeName :
-                        isSupportedExpressionWithTypeArguments(<ExpressionWithTypeArguments>node) ? (<ExpressionWithTypeArguments>node).expression :
-                            undefined;
+                    const typeNameOrExpression: EntityNameOrEntityNameExpression = node.kind === SyntaxKind.TypeReference
+                        ? (<TypeReferenceNode>node).typeName
+                        : isEntityNameExpression((<ExpressionWithTypeArguments>node).expression)
+                            ? <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression
+                            : undefined;
                     symbol = typeNameOrExpression && resolveEntityName(typeNameOrExpression, SymbolFlags.Type) || unknownSymbol;
                     type = symbol === unknownSymbol ? unknownType :
                         symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface) ? getTypeFromClassOrInterfaceReference(node, symbol) :
@@ -5219,16 +5238,47 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function createTupleType(elementTypes: Type[]) {
-            const id = getTypeListId(elementTypes);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes));
+        // We represent tuple types as type references to synthesized generic interface types created by
+        // this function. The types are of the form:
+        //
+        //   interface Tuple<T0, T1, T2, ...> extends Array<T0 | T1 | T2 | ...> { 0: T0, 1: T1, 2: T2, ... }
+        //
+        // Note that the generic type created by this function has no symbol associated with it. The same
+        // is true for each of the synthesized type parameters.
+        function createTupleTypeOfArity(arity: number): GenericType {
+            const typeParameters: TypeParameter[] = [];
+            const properties: Symbol[] = [];
+            for (let i = 0; i < arity; i++) {
+                const typeParameter = <TypeParameter>createType(TypeFlags.TypeParameter);
+                typeParameters.push(typeParameter);
+                const property = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
+                property.type = typeParameter;
+                properties.push(property);
+            }
+            const type = <GenericType & InterfaceTypeWithDeclaredMembers>createObjectType(TypeFlags.Tuple | TypeFlags.Reference);
+            type.typeParameters = typeParameters;
+            type.outerTypeParameters = undefined;
+            type.localTypeParameters = typeParameters;
+            type.instantiations = createMap<TypeReference>();
+            type.instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
+            type.target = <GenericType>type;
+            type.typeArguments = type.typeParameters;
+            type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter | TypeFlags.ThisType);
+            type.thisType.constraint = type;
+            type.declaredProperties = properties;
+            type.declaredCallSignatures = emptyArray;
+            type.declaredConstructSignatures = emptyArray;
+            type.declaredStringIndexInfo = undefined;
+            type.declaredNumberIndexInfo = undefined;
+            return type;
         }
 
-        function createNewTupleType(elementTypes: Type[]) {
-            const propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
-            const type = <TupleType>createObjectType(TypeFlags.Tuple | propagatedFlags);
-            type.elementTypes = elementTypes;
-            return type;
+        function getTupleTypeOfArity(arity: number): GenericType {
+            return tupleTypes[arity] || (tupleTypes[arity] = createTupleTypeOfArity(arity));
+        }
+
+        function createTupleType(elementTypes: Type[]) {
+            return createTypeReference(getTupleTypeOfArity(elementTypes.length), elementTypes);
         }
 
         function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
@@ -5329,12 +5379,12 @@ namespace ts {
             }
         }
 
-        // We deduplicate the constituent types based on object identity. If the subtypeReduction flag is
-        // specified we also reduce the constituent type set to only include types that aren't subtypes of
-        // other types. Subtype reduction is expensive for large union types and is possible only when union
+        // We sort and deduplicate the constituent types based on object identity. If the subtypeReduction
+        // flag is specified we also reduce the constituent type set to only include types that aren't subtypes
+        // of other types. Subtype reduction is expensive for large union types and is possible only when union
         // types are known not to circularly reference themselves (as is the case with union types created by
         // expression constructs such as array literals and the || and ?: operators). Named types can
-        // circularly reference themselves and therefore cannot be deduplicated during their declaration.
+        // circularly reference themselves and therefore cannot be subtype reduced during their declaration.
         // For example, "type Item = string | (() => Item" is a named type that circularly references itself.
         function getUnionType(types: Type[], subtypeReduction?: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
             if (types.length === 0) {
@@ -5356,15 +5406,23 @@ namespace ts {
                     typeSet.containsUndefined ? typeSet.containsNonWideningType ? undefinedType : undefinedWideningType :
                         neverType;
             }
-            else if (typeSet.length === 1) {
-                return typeSet[0];
+            return getUnionTypeFromSortedList(typeSet, aliasSymbol, aliasTypeArguments);
+        }
+
+        // This function assumes the constituent type list is sorted and deduplicated.
+        function getUnionTypeFromSortedList(types: Type[], aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
+            if (types.length === 0) {
+                return neverType;
             }
-            const id = getTypeListId(typeSet);
+            if (types.length === 1) {
+                return types[0];
+            }
+            const id = getTypeListId(types);
             let type = unionTypes[id];
             if (!type) {
-                const propagatedFlags = getPropagatingFlagsOfTypes(typeSet, /*excludeKinds*/ TypeFlags.Nullable);
+                const propagatedFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ TypeFlags.Nullable);
                 type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | propagatedFlags);
-                type.types = typeSet;
+                type.types = types;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
             }
@@ -5456,7 +5514,7 @@ namespace ts {
 
         function getLiteralTypeForText(flags: TypeFlags, text: string) {
             const map = flags & TypeFlags.StringLiteral ? stringLiteralTypes : numericLiteralTypes;
-            return hasProperty(map, text) ? map[text] : map[text] = createLiteralType(flags, text);
+            return map[text] || (map[text] = createLiteralType(flags, text));
         }
 
         function getTypeFromLiteralTypeNode(node: LiteralTypeNode): Type {
@@ -5532,11 +5590,19 @@ namespace ts {
                     return nullType;
                 case SyntaxKind.NeverKeyword:
                     return neverType;
+                case SyntaxKind.JSDocNullKeyword:
+                    return nullType;
+                case SyntaxKind.JSDocUndefinedKeyword:
+                    return undefinedType;
+                case SyntaxKind.JSDocNeverKeyword:
+                    return neverType;
                 case SyntaxKind.ThisType:
                 case SyntaxKind.ThisKeyword:
                     return getTypeFromThisTypeNode(node);
                 case SyntaxKind.LiteralType:
                     return getTypeFromLiteralTypeNode(<LiteralTypeNode>node);
+                case SyntaxKind.JSDocLiteralType:
+                    return getTypeFromLiteralTypeNode((<JSDocLiteralType>node).literal);
                 case SyntaxKind.TypeReference:
                 case SyntaxKind.JSDocTypeReference:
                     return getTypeFromTypeReference(<TypeReferenceNode>node);
@@ -5823,9 +5889,6 @@ namespace ts {
                 if (type.flags & TypeFlags.Reference) {
                     return createTypeReference((<TypeReference>type).target, instantiateList((<TypeReference>type).typeArguments, mapper, instantiateType));
                 }
-                if (type.flags & TypeFlags.Tuple) {
-                    return createTupleType(instantiateList((<TupleType>type).elementTypes, mapper, instantiateType));
-                }
                 if (type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Primitive)) {
                     return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*subtypeReduction*/ false, type.aliasSymbol, mapper.targetTypes);
                 }
@@ -5917,6 +5980,13 @@ namespace ts {
             return isTypeRelatedTo(source, target, assignableRelation);
         }
 
+        // A type S is considered to be an instance of a type T if S and T are the same type or if S is a
+        // subtype of T but not structurally identical to T. This specifically means that two distinct but
+        // structurally identical types (such as two classes) are not considered instances of each other.
+        function isTypeInstanceOf(source: Type, target: Type): boolean {
+            return source === target || isTypeSubtypeOf(source, target) && !isTypeIdenticalTo(source, target);
+        }
+
         /**
          * This is *not* a bi-directional relationship.
          * If one needs to check both directions for comparability, use a second call to this function or 'checkTypeComparableTo'.
@@ -6238,6 +6308,18 @@ namespace ts {
                 reportError(message, sourceType, targetType);
             }
 
+            function tryElaborateErrorsForPrimitivesAndObjects(source: Type, target: Type) {
+                const sourceType = typeToString(source);
+                const targetType = typeToString(target);
+
+                if ((globalStringType === source && stringType === target) ||
+                    (globalNumberType === source && numberType === target) ||
+                    (globalBooleanType === source && booleanType === target) ||
+                    (getGlobalESSymbolType() === source && esSymbolType === target)) {
+                        reportError(Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
+                }
+            }
+
             // Compare two types and return
             // Ternary.True if they are related with no assumptions,
             // Ternary.Maybe if they are related with assumptions of other relationships, or
@@ -6361,6 +6443,9 @@ namespace ts {
                 }
 
                 if (reportErrors) {
+                    if (source.flags & TypeFlags.ObjectType && target.flags & TypeFlags.Primitive) {
+                        tryElaborateErrorsForPrimitivesAndObjects(source, target);
+                    }
                     reportRelationError(headMessage, source, target);
                 }
                 return Ternary.False;
@@ -6568,7 +6653,7 @@ namespace ts {
                 }
                 sourceStack[depth] = source;
                 targetStack[depth] = target;
-                maybeStack[depth] = {};
+                maybeStack[depth] = createMap<RelationComparisonResult>();
                 maybeStack[depth][id] = RelationComparisonResult.Succeeded;
                 depth++;
                 const saveExpandingFlags = expandingFlags;
@@ -6599,7 +6684,7 @@ namespace ts {
                     const maybeCache = maybeStack[depth];
                     // If result is definitely true, copy assumptions to global cache, else copy to next level up
                     const destinationCache = (result === Ternary.True || depth === 0) ? relation : maybeStack[depth - 1];
-                    copyMap(maybeCache, destinationCache);
+                    copyProperties(maybeCache, destinationCache);
                 }
                 else {
                     // A false result goes straight into global cache (when something is false under assumptions it
@@ -7139,8 +7224,8 @@ namespace ts {
          * Check if a Type was written as a tuple type literal.
          * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
          */
-        function isTupleType(type: Type): type is TupleType {
-            return !!(type.flags & TypeFlags.Tuple);
+        function isTupleType(type: Type): boolean {
+            return !!(type.flags & TypeFlags.Reference && (<TypeReference>type).target.flags & TypeFlags.Tuple);
         }
 
         function getFalsyFlagsOfTypes(types: Type[]): TypeFlags {
@@ -7209,7 +7294,7 @@ namespace ts {
         }
 
         function transformTypeOfMembers(type: Type, f: (propertyType: Type) => Type) {
-            const members: SymbolTable = {};
+            const members = createMap<Symbol>();
             for (const property of getPropertiesOfObjectType(type)) {
                 const original = getTypeOfSymbol(property);
                 const updated = f(original);
@@ -7272,11 +7357,8 @@ namespace ts {
                 if (type.flags & TypeFlags.Union) {
                     return getUnionType(map((<UnionType>type).types, getWidenedConstituentType));
                 }
-                if (isArrayType(type)) {
-                    return createArrayType(getWidenedType((<TypeReference>type).typeArguments[0]));
-                }
-                if (isTupleType(type)) {
-                    return createTupleType(map(type.elementTypes, getWidenedType));
+                if (isArrayType(type) || isTupleType(type)) {
+                    return createTypeReference((<TypeReference>type).target, map((<TypeReference>type).typeArguments, getWidenedType));
                 }
             }
             return type;
@@ -7302,11 +7384,8 @@ namespace ts {
                     }
                 }
             }
-            if (isArrayType(type)) {
-                return reportWideningErrorsInType((<TypeReference>type).typeArguments[0]);
-            }
-            if (isTupleType(type)) {
-                for (const t of type.elementTypes) {
+            if (isArrayType(type) || isTupleType(type)) {
+                for (const t of (<TypeReference>type).typeArguments) {
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
                     }
@@ -7416,7 +7495,6 @@ namespace ts {
         function couldContainTypeParameters(type: Type): boolean {
             return !!(type.flags & TypeFlags.TypeParameter ||
                 type.flags & TypeFlags.Reference && forEach((<TypeReference>type).typeArguments, couldContainTypeParameters) ||
-                type.flags & TypeFlags.Tuple && forEach((<TupleType>type).elementTypes, couldContainTypeParameters) ||
                 type.flags & TypeFlags.Anonymous && type.symbol && type.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral | SymbolFlags.Class) ||
                 type.flags & TypeFlags.UnionOrIntersection && couldUnionOrIntersectionContainTypeParameters(<UnionOrIntersectionType>type));
         }
@@ -7433,7 +7511,7 @@ namespace ts {
             let targetStack: Type[];
             let depth = 0;
             let inferiority = 0;
-            const visited: Map<boolean> = {};
+            const visited = createMap<boolean>();
             inferFromTypes(source, target);
 
             function isInProcess(source: Type, target: Type) {
@@ -7519,14 +7597,6 @@ namespace ts {
                         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
-                    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) {
                     const targetTypes = (<UnionOrIntersectionType>target).types;
                     let typeParameterCount = 0;
@@ -7567,7 +7637,7 @@ namespace ts {
                             return;
                         }
                         const key = source.id + "," + target.id;
-                        if (hasProperty(visited, key)) {
+                        if (visited[key]) {
                             return;
                         }
                         visited[key] = true;
@@ -7801,8 +7871,49 @@ namespace ts {
             return false;
         }
 
-        function rootContainsMatchingReference(source: Node, target: Node) {
-            return target.kind === SyntaxKind.PropertyAccessExpression && containsMatchingReference(source, (<PropertyAccessExpression>target).expression);
+        // Return true if target is a property access xxx.yyy, source is a property access xxx.zzz, the declared
+        // type of xxx is a union type, and yyy is a property that is possibly a discriminant. We consider a property
+        // a possible discriminant if its type differs in the constituents of containing union type, and if every
+        // choice is a unit type or a union of unit types.
+        function containsMatchingReferenceDiscriminant(source: Node, target: Node) {
+            return target.kind === SyntaxKind.PropertyAccessExpression &&
+                containsMatchingReference(source, (<PropertyAccessExpression>target).expression) &&
+                isDiscriminantProperty(getDeclaredTypeOfReference((<PropertyAccessExpression>target).expression), (<PropertyAccessExpression>target).name.text);
+        }
+
+        function getDeclaredTypeOfReference(expr: Node): Type {
+            if (expr.kind === SyntaxKind.Identifier) {
+                return getTypeOfSymbol(getResolvedSymbol(<Identifier>expr));
+            }
+            if (expr.kind === SyntaxKind.PropertyAccessExpression) {
+                const type = getDeclaredTypeOfReference((<PropertyAccessExpression>expr).expression);
+                return type && getTypeOfPropertyOfType(type, (<PropertyAccessExpression>expr).name.text);
+            }
+            return undefined;
+        }
+
+        function isDiscriminantProperty(type: Type, name: string) {
+            if (type && type.flags & TypeFlags.Union) {
+                let prop = getPropertyOfType(type, name);
+                if (!prop) {
+                    // The type may be a union that includes nullable or primitive types. If filtering
+                    // those out produces a different type, get the property from that type instead.
+                    // Effectively, we're checking if this *could* be a discriminant property once nullable
+                    // and primitive types are removed by other type guards.
+                    const filteredType = getTypeWithFacts(type, TypeFacts.Discriminatable);
+                    if (filteredType !== type && filteredType.flags & TypeFlags.Union) {
+                        prop = getPropertyOfType(filteredType, name);
+                    }
+                }
+                if (prop && prop.flags & SymbolFlags.SyntheticProperty) {
+                    if ((<TransientSymbol>prop).isDiscriminantProperty === undefined) {
+                        (<TransientSymbol>prop).isDiscriminantProperty = !(<TransientSymbol>prop).hasCommonType &&
+                            isUnitUnionType(getTypeOfSymbol(prop));
+                    }
+                    return (<TransientSymbol>prop).isDiscriminantProperty;
+                }
+            }
+            return false;
         }
 
         function isOrContainsMatchingReference(source: Node, target: Node) {
@@ -7848,10 +7959,10 @@ namespace ts {
         // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
         // we remove type string.
         function getAssignmentReducedType(declaredType: UnionType, assignedType: Type) {
-            if (declaredType !== assignedType && declaredType.flags & TypeFlags.Union) {
-                const reducedTypes = filter(declaredType.types, t => typeMaybeAssignableTo(assignedType, t));
-                if (reducedTypes.length) {
-                    return reducedTypes.length === 1 ? reducedTypes[0] : getUnionType(reducedTypes);
+            if (declaredType !== assignedType) {
+                const reducedType = filterType(declaredType, t => typeMaybeAssignableTo(assignedType, t));
+                if (reducedType !== neverType) {
+                    return reducedType;
                 }
             }
             return declaredType;
@@ -7865,6 +7976,14 @@ namespace ts {
             return result;
         }
 
+        function isFunctionObjectType(type: ObjectType): boolean {
+            // We do a quick check for a "bind" property before performing the more expensive subtype
+            // check. This gives us a quicker out in the common case where an object type is not a function.
+            const resolved = resolveStructuredTypeMembers(type);
+            return !!(resolved.callSignatures.length || resolved.constructSignatures.length ||
+                resolved.members["bind"] && isTypeSubtypeOf(type, globalFunctionType));
+        }
+
         function getTypeFacts(type: Type): TypeFacts {
             const flags = type.flags;
             if (flags & TypeFlags.String) {
@@ -7893,8 +8012,7 @@ namespace ts {
                     type === falseType ? TypeFacts.FalseFacts : TypeFacts.TrueFacts;
             }
             if (flags & TypeFlags.ObjectType) {
-                const resolved = resolveStructuredTypeMembers(type);
-                return resolved.callSignatures.length || resolved.constructSignatures.length || isTypeSubtypeOf(type, globalFunctionType) ?
+                return isFunctionObjectType(<ObjectType>type) ?
                     strictNullChecks ? TypeFacts.FunctionStrictFacts : TypeFacts.FunctionFacts :
                     strictNullChecks ? TypeFacts.ObjectStrictFacts : TypeFacts.ObjectFacts;
             }
@@ -7909,7 +8027,7 @@ namespace ts {
             }
             if (flags & TypeFlags.TypeParameter) {
                 const constraint = getConstraintOfTypeParameter(<TypeParameter>type);
-                return constraint ? getTypeFacts(constraint) : TypeFacts.All;
+                return getTypeFacts(constraint || emptyObjectType);
             }
             if (flags & TypeFlags.UnionOrIntersection) {
                 return getTypeFactsOfTypes((<UnionOrIntersectionType>type).types);
@@ -7918,25 +8036,7 @@ namespace ts {
         }
 
         function getTypeWithFacts(type: Type, include: TypeFacts) {
-            if (!(type.flags & TypeFlags.Union)) {
-                return getTypeFacts(type) & include ? type : neverType;
-            }
-            let firstType: Type;
-            let types: Type[];
-            for (const t of (type as UnionType).types) {
-                if (getTypeFacts(t) & include) {
-                    if (!firstType) {
-                        firstType = t;
-                    }
-                    else {
-                        if (!types) {
-                            types = [firstType];
-                        }
-                        types.push(t);
-                    }
-                }
-            }
-            return firstType ? types ? getUnionType(types) : firstType : neverType;
+            return filterType(type, t => (getTypeFacts(t) & include) !== 0);
         }
 
         function getTypeWithDefault(type: Type, defaultExpression: Expression) {
@@ -8092,10 +8192,32 @@ namespace ts {
             return source.flags & TypeFlags.Union ? !forEach((<UnionType>source).types, t => !contains(types, t)) : contains(types, source);
         }
 
+        function isTypeSubsetOf(source: Type, target: Type) {
+            return source === target || target.flags & TypeFlags.Union && isTypeSubsetOfUnion(source, <UnionType>target);
+        }
+
+        function isTypeSubsetOfUnion(source: Type, target: UnionType) {
+            if (source.flags & TypeFlags.Union) {
+                for (const t of (<UnionType>source).types) {
+                    if (!containsType(target.types, t)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if (source.flags & TypeFlags.EnumLiteral && target.flags & TypeFlags.Enum && (<EnumLiteralType>source).baseType === target) {
+                return true;
+            }
+            return containsType(target.types, source);
+        }
+
         function filterType(type: Type, f: (t: Type) => boolean): Type {
-            return type.flags & TypeFlags.Union ?
-                getUnionType(filter((<UnionType>type).types, f)) :
-                f(type) ? type : neverType;
+            if (type.flags & TypeFlags.Union) {
+                const types = (<UnionType>type).types;
+                const filtered = filter(types, f);
+                return filtered === types ? type : getUnionTypeFromSortedList(filtered);
+            }
+            return f(type) ? type : neverType;
         }
 
         function isIncomplete(flowType: FlowType) {
@@ -8110,7 +8232,7 @@ namespace ts {
             return incomplete ? { flags: 0, type } : type;
         }
 
-        function getFlowTypeOfReference(reference: Node, declaredType: Type, assumeInitialized: boolean, includeOuterFunctions: boolean) {
+        function getFlowTypeOfReference(reference: Node, declaredType: Type, assumeInitialized: boolean, flowContainer: Node) {
             let key: string;
             if (!reference.flowNode || assumeInitialized && !(declaredType.flags & TypeFlags.Narrowable)) {
                 return declaredType;
@@ -8162,7 +8284,7 @@ namespace ts {
                     else if (flow.flags & FlowFlags.Start) {
                         // Check if we should continue with the control flow of the containing function.
                         const container = (<FlowStart>flow).container;
-                        if (container && includeOuterFunctions) {
+                        if (container && container !== flowContainer && reference.kind !== SyntaxKind.PropertyAccessExpression) {
                             flow = container.flowNode;
                             continue;
                         }
@@ -8230,7 +8352,7 @@ namespace ts {
                 if (isMatchingReference(reference, expr)) {
                     type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
                 }
-                else if (isMatchingPropertyAccess(expr)) {
+                else if (isMatchingReferenceDiscriminant(expr)) {
                     type = narrowTypeByDiscriminant(type, <PropertyAccessExpression>expr, t => narrowTypeBySwitchOnDiscriminant(t, flow.switchStatement, flow.clauseStart, flow.clauseEnd));
                 }
                 return createFlowType(type, isIncomplete(flowType));
@@ -8238,6 +8360,7 @@ namespace ts {
 
             function getTypeAtFlowBranchLabel(flow: FlowLabel): FlowType {
                 const antecedentTypes: Type[] = [];
+                let subtypeReduction = false;
                 let seenIncomplete = false;
                 for (const antecedent of flow.antecedents) {
                     const flowType = getTypeAtFlowNode(antecedent);
@@ -8252,18 +8375,24 @@ namespace ts {
                     if (!contains(antecedentTypes, type)) {
                         antecedentTypes.push(type);
                     }
+                    // If an antecedent type is not a subset of the declared type, we need to perform
+                    // subtype reduction. This happens when a "foreign" type is injected into the control
+                    // flow using the instanceof operator or a user defined type predicate.
+                    if (!isTypeSubsetOf(type, declaredType)) {
+                        subtypeReduction = true;
+                    }
                     if (isIncomplete(flowType)) {
                         seenIncomplete = true;
                     }
                 }
-                return createFlowType(getUnionType(antecedentTypes), seenIncomplete);
+                return createFlowType(getUnionType(antecedentTypes, subtypeReduction), seenIncomplete);
             }
 
             function getTypeAtFlowLoopLabel(flow: FlowLabel): FlowType {
                 // If we have previously computed the control flow type for the reference at
                 // this flow loop junction, return the cached type.
                 const id = getFlowNodeId(flow);
-                const cache = flowLoopCaches[id] || (flowLoopCaches[id] = {});
+                const cache = flowLoopCaches[id] || (flowLoopCaches[id] = createMap<Type>());
                 if (!key) {
                     key = getFlowCacheKey(reference);
                 }
@@ -8282,13 +8411,19 @@ namespace ts {
                 // Add the flow loop junction and reference to the in-process stack and analyze
                 // each antecedent code path.
                 const antecedentTypes: Type[] = [];
+                let subtypeReduction = false;
+                let firstAntecedentType: FlowType;
                 flowLoopNodes[flowLoopCount] = flow;
                 flowLoopKeys[flowLoopCount] = key;
                 flowLoopTypes[flowLoopCount] = antecedentTypes;
                 for (const antecedent of flow.antecedents) {
                     flowLoopCount++;
-                    const type = getTypeFromFlowType(getTypeAtFlowNode(antecedent));
+                    const flowType = getTypeAtFlowNode(antecedent);
                     flowLoopCount--;
+                    if (!firstAntecedentType) {
+                        firstAntecedentType = flowType;
+                    }
+                    const type = getTypeFromFlowType(flowType);
                     // If we see a value appear in the cache it is a sign that control flow  analysis
                     // was restarted and completed by checkExpressionCached. We can simply pick up
                     // the resulting type and bail out.
@@ -8298,6 +8433,12 @@ namespace ts {
                     if (!contains(antecedentTypes, type)) {
                         antecedentTypes.push(type);
                     }
+                    // If an antecedent type is not a subset of the declared type, we need to perform
+                    // subtype reduction. This happens when a "foreign" type is injected into the control
+                    // flow using the instanceof operator or a user defined type predicate.
+                    if (!isTypeSubsetOf(type, declaredType)) {
+                        subtypeReduction = true;
+                    }
                     // If the type at a particular antecedent path is the declared type there is no
                     // reason to process more antecedents since the only possible outcome is subtypes
                     // that will be removed in the final union type anyway.
@@ -8305,13 +8446,20 @@ namespace ts {
                         break;
                     }
                 }
-                return cache[key] = getUnionType(antecedentTypes);
+                // The result is incomplete if the first antecedent (the non-looping control flow path)
+                // is incomplete.
+                const result = getUnionType(antecedentTypes, subtypeReduction);
+                if (isIncomplete(firstAntecedentType)) {
+                    return createFlowType(result, /*incomplete*/ true);
+                }
+                return cache[key] = result;
             }
 
-            function isMatchingPropertyAccess(expr: Expression) {
+            function isMatchingReferenceDiscriminant(expr: Expression) {
                 return expr.kind === SyntaxKind.PropertyAccessExpression &&
+                    declaredType.flags & TypeFlags.Union &&
                     isMatchingReference(reference, (<PropertyAccessExpression>expr).expression) &&
-                    (declaredType.flags & TypeFlags.Union) !== 0;
+                    isDiscriminantProperty(declaredType, (<PropertyAccessExpression>expr).name.text);
             }
 
             function narrowTypeByDiscriminant(type: Type, propAccess: PropertyAccessExpression, narrowType: (t: Type) => Type): Type {
@@ -8325,10 +8473,10 @@ namespace ts {
                 if (isMatchingReference(reference, expr)) {
                     return getTypeWithFacts(type, assumeTrue ? TypeFacts.Truthy : TypeFacts.Falsy);
                 }
-                if (isMatchingPropertyAccess(expr)) {
+                if (isMatchingReferenceDiscriminant(expr)) {
                     return narrowTypeByDiscriminant(type, <PropertyAccessExpression>expr, t => getTypeWithFacts(t, assumeTrue ? TypeFacts.Truthy : TypeFacts.Falsy));
                 }
-                if (rootContainsMatchingReference(reference, expr)) {
+                if (containsMatchingReferenceDiscriminant(reference, expr)) {
                     return declaredType;
                 }
                 return type;
@@ -8357,13 +8505,13 @@ namespace ts {
                         if (isMatchingReference(reference, right)) {
                             return narrowTypeByEquality(type, operator, left, assumeTrue);
                         }
-                        if (isMatchingPropertyAccess(left)) {
+                        if (isMatchingReferenceDiscriminant(left)) {
                             return narrowTypeByDiscriminant(type, <PropertyAccessExpression>left, t => narrowTypeByEquality(t, operator, right, assumeTrue));
                         }
-                        if (isMatchingPropertyAccess(right)) {
+                        if (isMatchingReferenceDiscriminant(right)) {
                             return narrowTypeByDiscriminant(type, <PropertyAccessExpression>right, t => narrowTypeByEquality(t, operator, left, assumeTrue));
                         }
-                        if (rootContainsMatchingReference(reference, left) || rootContainsMatchingReference(reference, right)) {
+                        if (containsMatchingReferenceDiscriminant(reference, left) || containsMatchingReferenceDiscriminant(reference, right)) {
                             return declaredType;
                         }
                         break;
@@ -8418,16 +8566,16 @@ namespace ts {
                 }
                 if (assumeTrue && !(type.flags & TypeFlags.Union)) {
                     // We narrow a non-union type to an exact primitive type if the non-union type
-                    // is a supertype of that primtive type. For example, type 'any' can be narrowed
+                    // is a supertype of that primitive type. For example, type 'any' can be narrowed
                     // to one of the primitive types.
-                    const targetType = getProperty(typeofTypesByName, literal.text);
+                    const targetType = typeofTypesByName[literal.text];
                     if (targetType && isTypeSubtypeOf(targetType, type)) {
                         return targetType;
                     }
                 }
                 const facts = assumeTrue ?
-                    getProperty(typeofEQFacts, literal.text) || TypeFacts.TypeofEQHostObject :
-                    getProperty(typeofNEFacts, literal.text) || TypeFacts.TypeofNEHostObject;
+                    typeofEQFacts[literal.text] || TypeFacts.TypeofEQHostObject :
+                    typeofNEFacts[literal.text] || TypeFacts.TypeofNEHostObject;
                 return getTypeWithFacts(type, facts);
             }
 
@@ -8458,10 +8606,6 @@ namespace ts {
                     }
                     return type;
                 }
-                // We never narrow type any in an instanceof guard
-                if (isTypeAny(type)) {
-                    return type;
-                }
 
                 // Check that right operand is a function type with a prototype property
                 const rightType = checkExpression(expr.right);
@@ -8479,6 +8623,11 @@ namespace ts {
                     }
                 }
 
+                // Don't narrow from 'any' if the target type is exactly 'Object' or 'Function'
+                if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) {
+                    return type;
+                }
+
                 if (!targetType) {
                     // Target type is type of construct signature
                     let constructSignatures: Signature[];
@@ -8502,29 +8651,30 @@ namespace ts {
 
             function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean) {
                 if (!assumeTrue) {
-                    return type.flags & TypeFlags.Union ?
-                        getUnionType(filter((<UnionType>type).types, t => !isTypeSubtypeOf(t, candidate))) :
-                        type;
+                    return filterType(type, t => !isTypeInstanceOf(t, candidate));
                 }
-                // If the current type is a union type, remove all constituents that aren't assignable to
+                // If the current type is a union type, remove all constituents that couldn't be instances of
                 // the candidate type. If one or more constituents remain, return a union of those.
                 if (type.flags & TypeFlags.Union) {
-                    const assignableConstituents = filter((<UnionType>type).types, t => isTypeAssignableTo(t, candidate));
-                    if (assignableConstituents.length) {
-                        return getUnionType(assignableConstituents);
+                    const assignableType = filterType(type, t => isTypeInstanceOf(t, candidate));
+                    if (assignableType !== neverType) {
+                        return assignableType;
                     }
                 }
-                // If the candidate type is assignable to the target type, narrow to the candidate type.
-                // Otherwise, if the current type is assignable to the candidate, keep the current type.
-                // Otherwise, the types are completely unrelated, so narrow to the empty type.
+                // If the candidate type is a subtype of the target type, narrow to the candidate type.
+                // Otherwise, if the target type is assignable to the candidate type, keep the target type.
+                // Otherwise, if the candidate type is assignable to the target type, narrow to the candidate
+                // type. Otherwise, the types are completely unrelated, so narrow to an intersection of the
+                // two types.
                 const targetType = type.flags & TypeFlags.TypeParameter ? getApparentType(type) : type;
-                return isTypeAssignableTo(candidate, targetType) ? candidate :
+                return isTypeSubtypeOf(candidate, targetType) ? candidate :
                     isTypeAssignableTo(type, candidate) ? type :
-                        getIntersectionType([type, candidate]);
+                    isTypeAssignableTo(candidate, targetType) ? candidate :
+                    getIntersectionType([type, candidate]);
             }
 
             function narrowTypeByTypePredicate(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {
-                if (type.flags & TypeFlags.Any || !hasMatchingArgument(callExpression, reference)) {
+                if (!hasMatchingArgument(callExpression, reference)) {
                     return type;
                 }
                 const signature = getResolvedSignature(callExpression);
@@ -8532,6 +8682,12 @@ namespace ts {
                 if (!predicate) {
                     return type;
                 }
+
+                // Don't narrow from 'any' if the predicate type is exactly 'Object' or 'Function'
+                if (isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType)) {
+                    return type;
+                }
+
                 if (isIdentifierTypePredicate(predicate)) {
                     const predicateArgument = callExpression.arguments[predicate.parameterIndex];
                     if (predicateArgument) {
@@ -8617,21 +8773,52 @@ namespace ts {
         function getControlFlowContainer(node: Node): Node {
             while (true) {
                 node = node.parent;
-                if (isFunctionLike(node) || node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.SourceFile || node.kind === SyntaxKind.PropertyDeclaration) {
+                if (isFunctionLike(node) && !getImmediatelyInvokedFunctionExpression(node) ||
+                    node.kind === SyntaxKind.ModuleBlock ||
+                    node.kind === SyntaxKind.SourceFile ||
+                    node.kind === SyntaxKind.PropertyDeclaration) {
                     return node;
                 }
             }
         }
 
-        function isDeclarationIncludedInFlow(reference: Node, declaration: Declaration, includeOuterFunctions: boolean) {
-            const declarationContainer = getControlFlowContainer(declaration);
-            let container = getControlFlowContainer(reference);
-            while (container !== declarationContainer &&
-                (container.kind === SyntaxKind.FunctionExpression || container.kind === SyntaxKind.ArrowFunction) &&
-                (includeOuterFunctions || getImmediatelyInvokedFunctionExpression(<FunctionExpression>container))) {
-                container = getControlFlowContainer(container);
+        // Check if a parameter is assigned anywhere within its declaring function.
+        function isParameterAssigned(symbol: Symbol) {
+            const func = <FunctionLikeDeclaration>getRootDeclaration(symbol.valueDeclaration).parent;
+            const links = getNodeLinks(func);
+            if (!(links.flags & NodeCheckFlags.AssignmentsMarked)) {
+                links.flags |= NodeCheckFlags.AssignmentsMarked;
+                if (!hasParentWithAssignmentsMarked(func)) {
+                    markParameterAssignments(func);
+                }
+            }
+            return symbol.isAssigned || false;
+        }
+
+        function hasParentWithAssignmentsMarked(node: Node) {
+            while (true) {
+                node = node.parent;
+                if (!node) {
+                    return false;
+                }
+                if (isFunctionLike(node) && getNodeLinks(node).flags & NodeCheckFlags.AssignmentsMarked) {
+                    return true;
+                }
+            }
+        }
+
+        function markParameterAssignments(node: Node) {
+            if (node.kind === SyntaxKind.Identifier) {
+                if (isAssignmentTarget(node)) {
+                    const symbol = getResolvedSymbol(<Identifier>node);
+                    if (symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration).kind === SyntaxKind.Parameter) {
+                        symbol.isAssigned = true;
+                    }
+                }
+            }
+            else {
+                forEachChild(node, markParameterAssignments);
             }
-            return container === declarationContainer;
         }
 
         function checkIdentifier(node: Identifier): Type {
@@ -8708,15 +8895,35 @@ namespace ts {
             checkNestedBlockScopedBinding(node, symbol);
 
             const type = getTypeOfSymbol(localOrExportSymbol);
-            if (!(localOrExportSymbol.flags & SymbolFlags.Variable) || isAssignmentTarget(node)) {
+            const declaration = localOrExportSymbol.valueDeclaration;
+            // We only narrow variables and parameters occurring in a non-assignment position. For all other
+            // entities we simply return the declared type.
+            if (!(localOrExportSymbol.flags & SymbolFlags.Variable) || isAssignmentTarget(node) || !declaration) {
                 return type;
             }
-            const declaration = localOrExportSymbol.valueDeclaration;
-            const includeOuterFunctions = isReadonlySymbol(localOrExportSymbol);
-            const assumeInitialized = !strictNullChecks || (type.flags & TypeFlags.Any) !== 0 || !declaration ||
-                getRootDeclaration(declaration).kind === SyntaxKind.Parameter || isInAmbientContext(declaration) ||
-                !isDeclarationIncludedInFlow(node, declaration, includeOuterFunctions);
-            const flowType = getFlowTypeOfReference(node, type, assumeInitialized, includeOuterFunctions);
+            // The declaration container is the innermost function that encloses the declaration of the variable
+            // or parameter. The flow container is the innermost function starting with which we analyze the control
+            // flow graph to determine the control flow based type.
+            const isParameter = getRootDeclaration(declaration).kind === SyntaxKind.Parameter;
+            const declarationContainer = getControlFlowContainer(declaration);
+            let flowContainer = getControlFlowContainer(node);
+            // When the control flow originates in a function expression or arrow function and we are referencing
+            // a const variable or parameter from an outer function, we extend the origin of the control flow
+            // analysis to include the immediately enclosing function.
+            while (flowContainer !== declarationContainer &&
+                (flowContainer.kind === SyntaxKind.FunctionExpression || flowContainer.kind === SyntaxKind.ArrowFunction) &&
+                (isReadonlySymbol(localOrExportSymbol) || isParameter && !isParameterAssigned(localOrExportSymbol))) {
+                flowContainer = getControlFlowContainer(flowContainer);
+            }
+            // We only look for uninitialized variables in strict null checking mode, and only when we can analyze
+            // the entire control flow graph from the variable's declaration (i.e. when the flow container and
+            // declaration container are the same).
+            const assumeInitialized = !strictNullChecks || (type.flags & TypeFlags.Any) !== 0 || isParameter ||
+                flowContainer !== declarationContainer || isInAmbientContext(declaration);
+            const flowType = getFlowTypeOfReference(node, type, assumeInitialized, flowContainer);
+            // A variable is considered uninitialized when it is possible to analyze the entire control flow graph
+            // from declaration to use, and when the variable's declared type doesn't include undefined but the
+            // control flow based type does include undefined.
             if (!assumeInitialized && !(getFalsyFlags(type) & TypeFlags.Undefined) && getFalsyFlags(flowType) & TypeFlags.Undefined) {
                 error(node, Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
                 // Return the declared type to reduce follow-on errors
@@ -8956,20 +9163,17 @@ namespace ts {
                         return getInferredClassType(classSymbol);
                     }
                 }
-                const type = getContextuallyTypedThisType(container);
-                if (type) {
-                    return type;
-                }
 
                 const thisType = getThisTypeOfDeclaration(container);
                 if (thisType) {
                     return thisType;
                 }
             }
+
             if (isClassLike(container.parent)) {
                 const symbol = getSymbolOfNode(container.parent);
                 const type = hasModifier(container, ModifierFlags.Static) ? getTypeOfSymbol(symbol) : (<InterfaceType>getDeclaredTypeOfSymbol(symbol)).thisType;
-                return getFlowTypeOfReference(node, type, /*assumeInitialized*/ true, /*includeOuterFunctions*/ true);
+                return getFlowTypeOfReference(node, type, /*assumeInitialized*/ true, /*flowContainer*/ undefined);
             }
 
             if (isInJavaScriptFile(node)) {
@@ -9200,11 +9404,11 @@ namespace ts {
             }
         }
 
-        function getContextuallyTypedThisType(func: FunctionLikeDeclaration): Type {
+        function getContextualThisParameter(func: FunctionLikeDeclaration): Symbol {
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== SyntaxKind.ArrowFunction) {
                 const contextualSignature = getContextualSignature(func);
                 if (contextualSignature) {
-                    return getThisTypeOfSignature(contextualSignature);
+                    return contextualSignature.thisParameter;
                 }
             }
 
@@ -9275,7 +9479,7 @@ namespace ts {
                     }
                 }
                 if (isBindingPattern(declaration.name)) {
-                    return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ true);
+                    return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false);
                 }
                 if (isBindingPattern(declaration.parent)) {
                     const parentDeclaration = declaration.parent.parent;
@@ -9380,6 +9584,11 @@ namespace ts {
             const binaryExpression = <BinaryExpression>node.parent;
             const operator = binaryExpression.operatorToken.kind;
             if (operator >= SyntaxKind.FirstAssignment && operator <= SyntaxKind.LastAssignment) {
+                // Don't do this for special property assignments to avoid circularity
+                if (getSpecialPropertyAssignmentKind(binaryExpression) !== SpecialPropertyAssignmentKind.None) {
+                    return undefined;
+                }
+
                 // In an assignment expression, the right operand is contextually typed by the type of the left operand.
                 if (node === binaryExpression.right) {
                     return checkExpression(binaryExpression.left);
@@ -9764,7 +9973,7 @@ 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) {
-                    const type = createNewTupleType(elementTypes);
+                    const type = cloneTypeReference(createTupleType(elementTypes));
                     type.pattern = node;
                     return type;
                 }
@@ -9778,7 +9987,7 @@ namespace ts {
                         for (let i = elementTypes.length; i < patternElements.length; i++) {
                             const patternElement = patternElements[i];
                             if (hasDefaultValue(patternElement)) {
-                                elementTypes.push((<TupleType>contextualType).elementTypes[i]);
+                                elementTypes.push((<TypeReference>contextualType).typeArguments[i]);
                             }
                             else {
                                 if (patternElement.kind !== SyntaxKind.OmittedExpression) {
@@ -9871,7 +10080,7 @@ namespace ts {
             // Grammar checking
             checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
 
-            const propertiesTable: SymbolTable = {};
+            const propertiesTable = createMap<Symbol>();
             const propertiesArray: Symbol[] = [];
             const contextualType = getApparentTypeOfContextualType(node);
             const contextualTypeHasPattern = contextualType && contextualType.pattern &&
@@ -9962,7 +10171,7 @@ namespace ts {
             // type with those properties for which the binding pattern specifies a default value.
             if (contextualTypeHasPattern) {
                 for (const prop of getPropertiesOfType(contextualType)) {
-                    if (!hasProperty(propertiesTable, prop.name)) {
+                    if (!propertiesTable[prop.name]) {
                         if (!(prop.flags & SymbolFlags.Optional)) {
                             error(prop.valueDeclaration || (<TransientSymbol>prop).bindingElement,
                                 Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value);
@@ -10052,10 +10261,9 @@ namespace ts {
                 const correspondingPropSymbol = getPropertyOfType(elementAttributesType, node.name.text);
                 correspondingPropType = correspondingPropSymbol && getTypeOfSymbol(correspondingPropSymbol);
                 if (isUnhyphenatedJsxName(node.name.text)) {
-                    // Maybe there's a string indexer?
-                    const indexerType = getIndexTypeOfType(elementAttributesType, IndexKind.String);
-                    if (indexerType) {
-                        correspondingPropType = indexerType;
+                    const attributeType = getTypeOfPropertyOfType(elementAttributesType, getTextOfPropertyName(node.name)) || getIndexTypeOfType(elementAttributesType, IndexKind.String);
+                    if (attributeType) {
+                        correspondingPropType = attributeType;
                     }
                     else {
                         // If there's no corresponding property with this name, error
@@ -10090,7 +10298,7 @@ namespace ts {
             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 (!hasProperty(nameTable, prop.name)) {
+                if (!nameTable[prop.name]) {
                     const targetPropSym = getPropertyOfType(elementAttributesType, prop.name);
                     if (targetPropSym) {
                         const msg = chainDiagnosticMessages(undefined, Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property, prop.name);
@@ -10412,7 +10620,7 @@ namespace ts {
 
             const targetAttributesType = getJsxElementAttributesType(node);
 
-            const nameTable: Map<boolean> = {};
+            const nameTable = createMap<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
@@ -10436,7 +10644,7 @@ namespace ts {
                 const targetProperties = getPropertiesOfType(targetAttributesType);
                 for (let i = 0; i < targetProperties.length; i++) {
                     if (!(targetProperties[i].flags & SymbolFlags.Optional) &&
-                        !hasProperty(nameTable, targetProperties[i].name)) {
+                        !nameTable[targetProperties[i].name]) {
 
                         error(node, Diagnostics.Property_0_is_missing_in_type_1, targetProperties[i].name, typeToString(targetAttributesType));
                     }
@@ -10634,7 +10842,7 @@ namespace ts {
                 !(prop.flags & SymbolFlags.Method && propType.flags & TypeFlags.Union)) {
                 return propType;
             }
-            return getFlowTypeOfReference(node, propType, /*assumeInitialized*/ true, /*includeOuterFunctions*/ false);
+            return getFlowTypeOfReference(node, propType, /*assumeInitialized*/ true, /*flowContainer*/ undefined);
         }
 
         function isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean {
@@ -10759,10 +10967,11 @@ namespace ts {
             }
 
             // Check for compatible indexer types.
-            if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbol)) {
+            const allowedNullableFlags = strictNullChecks ? 0 : TypeFlags.Nullable;
+            if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbol | allowedNullableFlags)) {
 
                 // Try to use a number indexer.
-                if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, TypeFlags.NumberLike) || isForInVariableForNumericPropertyNames(node.argumentExpression)) {
+                if (isTypeAnyOrAllConstituentTypesHaveKind(indexType, TypeFlags.NumberLike | allowedNullableFlags) || isForInVariableForNumericPropertyNames(node.argumentExpression)) {
                     const numberIndexInfo = getIndexInfoOfType(objectType, IndexKind.Number);
                     if (numberIndexInfo) {
                         getNodeLinks(node).resolvedIndexInfo = numberIndexInfo;
@@ -12146,6 +12355,12 @@ namespace ts {
 
         function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) {
             const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            if (context.thisParameter) {
+                if (!signature.thisParameter) {
+                    signature.thisParameter = createTransientSymbol(context.thisParameter, undefined);
+                }
+                assignTypeToParameterAndFixTypeParameters(signature.thisParameter, getTypeOfSymbol(context.thisParameter), mapper);
+            }
             for (let i = 0; i < len; i++) {
                 const parameter = signature.parameters[i];
                 const contextualParameterType = getTypeAtPosition(context, i);
@@ -12889,8 +13104,11 @@ namespace ts {
                         return checkDestructuringAssignment(element, type, contextualMapper);
                     }
                     else {
+                        // We still need to check element expression here because we may need to set appropriate flag on the expression
+                        // such as NodeCheckFlags.LexicalThis on "this"expression.
+                        checkExpression(element);
                         if (isTupleType(sourceType)) {
-                            error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), (<TupleType>sourceType).elementTypes.length, elements.length);
+                            error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), getTypeReferenceArity(<TypeReference>sourceType), elements.length);
                         }
                         else {
                             error(element, Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName);
@@ -13719,15 +13937,19 @@ namespace ts {
         }
 
         function checkClassForDuplicateDeclarations(node: ClassLikeDeclaration) {
-            const getter = 1, setter = 2, property = getter | setter;
+            const enum Accessor {
+                Getter = 1,
+                Setter = 2,
+                Property = Getter | Setter
+            }
 
-            const instanceNames: Map<number> = {};
-            const staticNames: Map<number> = {};
+            const instanceNames = createMap<Accessor>();
+            const staticNames = createMap<Accessor>();
             for (const member of node.members) {
                 if (member.kind === SyntaxKind.Constructor) {
                     for (const param of (member as ConstructorDeclaration).parameters) {
                         if (isParameterPropertyDeclaration(param)) {
-                            addName(instanceNames, param.name, (param.name as Identifier).text, property);
+                            addName(instanceNames, param.name, (param.name as Identifier).text, Accessor.Property);
                         }
                     }
                 }
@@ -13739,24 +13961,24 @@ namespace ts {
                     if (memberName) {
                         switch (member.kind) {
                             case SyntaxKind.GetAccessor:
-                                addName(names, member.name, memberName, getter);
+                                addName(names, member.name, memberName, Accessor.Getter);
                                 break;
 
                             case SyntaxKind.SetAccessor:
-                                addName(names, member.name, memberName, setter);
+                                addName(names, member.name, memberName, Accessor.Setter);
                                 break;
 
                             case SyntaxKind.PropertyDeclaration:
-                                addName(names, member.name, memberName, property);
+                                addName(names, member.name, memberName, Accessor.Property);
                                 break;
                         }
                     }
                 }
             }
 
-            function addName(names: Map<number>, location: Node, name: string, meaning: number) {
-                if (hasProperty(names, name)) {
-                    const prev = names[name];
+            function addName(names: Map<Accessor>, location: Node, name: string, meaning: Accessor) {
+                const prev = names[name];
+                if (prev) {
                     if (prev & meaning) {
                         error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
                     }
@@ -13771,7 +13993,7 @@ namespace ts {
         }
 
         function checkObjectTypeForDuplicateDeclarations(node: TypeLiteralNode | InterfaceDeclaration) {
-            const names: Map<boolean> = {};
+            const names = createMap<boolean>();
             for (const member of node.members) {
                 if (member.kind == SyntaxKind.PropertySignature) {
                     let memberName: string;
@@ -13785,7 +14007,7 @@ namespace ts {
                             continue;
                     }
 
-                    if (hasProperty(names, memberName)) {
+                    if (names[memberName]) {
                         error(member.symbol.valueDeclaration.name, Diagnostics.Duplicate_identifier_0, memberName);
                         error(member.name, Diagnostics.Duplicate_identifier_0, memberName);
                     }
@@ -13974,12 +14196,7 @@ namespace ts {
                 checkSignatureDeclaration(node);
                 if (node.kind === SyntaxKind.GetAccessor) {
                     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 {
+                        if (!(node.flags & NodeFlags.HasExplicitReturn)) {
                             error(node.name, Diagnostics.A_get_accessor_must_return_a_value);
                         }
                     }
@@ -14009,7 +14226,10 @@ namespace ts {
                         checkAccessorDeclarationTypesIdentical(node, otherAccessor, getThisTypeOfDeclaration, Diagnostics.get_and_set_accessor_must_have_the_same_this_type);
                     }
                 }
-                getTypeOfAccessors(getSymbolOfNode(node));
+                const returnType = getTypeOfAccessors(getSymbolOfNode(node));
+                if (node.kind === SyntaxKind.GetAccessor) {
+                    checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
+                }
             }
             if (node.parent.kind !== SyntaxKind.ObjectLiteralExpression) {
                 checkSourceElement(node.body);
@@ -14997,22 +15217,20 @@ namespace ts {
         function checkUnusedLocalsAndParameters(node: Node): void {
             if (node.parent.kind !== SyntaxKind.InterfaceDeclaration && noUnusedIdentifiers && !isInAmbientContext(node)) {
                 for (const key in node.locals) {
-                    if (hasProperty(node.locals, key)) {
-                        const local = node.locals[key];
-                        if (!local.isReferenced) {
-                            if (local.valueDeclaration && local.valueDeclaration.kind === SyntaxKind.Parameter) {
-                                const parameter = <ParameterDeclaration>local.valueDeclaration;
-                                if (compilerOptions.noUnusedParameters &&
-                                    !isParameterPropertyDeclaration(parameter) &&
-                                    !parameterIsThisKeyword(parameter) &&
-                                    !parameterNameStartsWithUnderscore(parameter)) {
-                                    error(local.valueDeclaration.name, Diagnostics._0_is_declared_but_never_used, local.name);
-                                }
-                            }
-                            else if (compilerOptions.noUnusedLocals) {
-                                forEach(local.declarations, d => error(d.name || d, Diagnostics._0_is_declared_but_never_used, local.name));
+                    const local = node.locals[key];
+                    if (!local.isReferenced) {
+                        if (local.valueDeclaration && local.valueDeclaration.kind === SyntaxKind.Parameter) {
+                            const parameter = <ParameterDeclaration>local.valueDeclaration;
+                            if (compilerOptions.noUnusedParameters &&
+                                !isParameterPropertyDeclaration(parameter) &&
+                                !parameterIsThisKeyword(parameter) &&
+                                !parameterNameStartsWithUnderscore(parameter)) {
+                                error(local.valueDeclaration.name, Diagnostics._0_is_declared_but_never_used, local.name);
                             }
                         }
+                        else if (compilerOptions.noUnusedLocals) {
+                            forEach(local.declarations, d => error(d.name || d, Diagnostics._0_is_declared_but_never_used, local.name));
+                        }
                     }
                 }
             }
@@ -15038,7 +15256,7 @@ namespace ts {
                         else if (member.kind === SyntaxKind.Constructor) {
                             for (const parameter of (<ConstructorDeclaration>member).parameters) {
                                 if (!parameter.symbol.isReferenced && getModifierFlags(parameter) & ModifierFlags.Private) {
-                                    error(parameter.name, Diagnostics._0_is_declared_but_never_used, parameter.symbol.name);
+                                    error(parameter.name, Diagnostics.Property_0_is_declared_but_never_used, parameter.symbol.name);
                                 }
                             }
                         }
@@ -15069,13 +15287,11 @@ namespace ts {
         function checkUnusedModuleMembers(node: ModuleDeclaration | SourceFile): void {
             if (compilerOptions.noUnusedLocals && !isInAmbientContext(node)) {
                 for (const key in node.locals) {
-                    if (hasProperty(node.locals, key)) {
-                        const local = node.locals[key];
-                        if (!local.isReferenced && !local.exportSymbol) {
-                            for (const declaration of local.declarations) {
-                                if (!isAmbientModule(declaration)) {
-                                    error(declaration.name, Diagnostics._0_is_declared_but_never_used, local.name);
-                                }
+                    const local = node.locals[key];
+                    if (!local.isReferenced && !local.exportSymbol) {
+                        for (const declaration of local.declarations) {
+                            if (!isAmbientModule(declaration)) {
+                                error(declaration.name, Diagnostics._0_is_declared_but_never_used, local.name);
                             }
                         }
                     }
@@ -16084,7 +16300,7 @@ namespace ts {
                     else {
                         const identifierName = (<Identifier>catchClause.variableDeclaration.name).text;
                         const locals = catchClause.block.locals;
-                        if (locals && hasProperty(locals, identifierName)) {
+                        if (locals) {
                             const localSymbol = locals[identifierName];
                             if (localSymbol && (localSymbol.flags & SymbolFlags.BlockScopedVariable) !== 0) {
                                 grammarErrorOnNode(localSymbol.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, identifierName);
@@ -16321,7 +16537,7 @@ namespace ts {
             const implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
                 for (const typeRefNode of implementedTypeNodes) {
-                    if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
+                    if (!isEntityNameExpression(typeRefNode.expression)) {
                         error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
                     checkTypeReferenceNode(typeRefNode);
@@ -16505,18 +16721,18 @@ namespace ts {
                 return true;
             }
 
-            const seen: Map<{ prop: Symbol; containingType: Type }> = {};
+            const seen = createMap<{ prop: Symbol; containingType: Type }>();
             forEach(resolveDeclaredMembers(type).declaredProperties, p => { seen[p.name] = { prop: p, containingType: type }; });
             let ok = true;
 
             for (const base of baseTypes) {
                 const properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType));
                 for (const prop of properties) {
-                    if (!hasProperty(seen, prop.name)) {
+                    const existing = seen[prop.name];
+                    if (!existing) {
                         seen[prop.name] = { prop: prop, containingType: base };
                     }
                     else {
-                        const existing = seen[prop.name];
                         const isInheritedProperty = existing.containingType !== type;
                         if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
                             ok = false;
@@ -16563,7 +16779,7 @@ namespace ts {
                 checkObjectTypeForDuplicateDeclarations(node);
             }
             forEach(getInterfaceBaseTypeNodes(node), heritageElement => {
-                if (!isSupportedExpressionWithTypeArguments(heritageElement)) {
+                if (!isEntityNameExpression(heritageElement.expression)) {
                     error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
                 }
                 checkTypeReferenceNode(heritageElement);
@@ -16963,11 +17179,6 @@ namespace ts {
                 }
             }
 
-            if (compilerOptions.noImplicitAny && !node.body) {
-                // Ambient shorthand module is an implicit any
-                reportImplicitAnyError(node, anyType);
-            }
-
             if (node.body) {
                 checkSourceElement(node.body);
                 if (!isGlobalScopeAugmentation(node)) {
@@ -17028,20 +17239,21 @@ namespace ts {
             }
         }
 
-        function getFirstIdentifier(node: EntityName | Expression): Identifier {
-            while (true) {
-                if (node.kind === SyntaxKind.QualifiedName) {
-                    node = (<QualifiedName>node).left;
-                }
-                else if (node.kind === SyntaxKind.PropertyAccessExpression) {
-                    node = (<PropertyAccessExpression>node).expression;
-                }
-                else {
-                    break;
-                }
+        function getFirstIdentifier(node: EntityNameOrEntityNameExpression): Identifier {
+            switch (node.kind) {
+                case SyntaxKind.Identifier:
+                    return <Identifier>node;
+                case SyntaxKind.QualifiedName:
+                    do {
+                        node = (<QualifiedName>node).left;
+                    } while (node.kind !== SyntaxKind.Identifier);
+                    return <Identifier>node;
+                case SyntaxKind.PropertyAccessExpression:
+                    do {
+                        node = (<PropertyAccessEntityNameExpression>node).expression;
+                    } while (node.kind !== SyntaxKind.Identifier);
+                    return <Identifier>node;
             }
-            Debug.assert(node.kind === SyntaxKind.Identifier);
-            return <Identifier>node;
         }
 
         function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {
@@ -17470,11 +17682,10 @@ namespace ts {
         }
 
         function checkSourceFile(node: SourceFile) {
-            const start = performance.mark();
-
+            performance.mark("beforeCheck");
             checkSourceFileWorker(node);
-
-            performance.measure("Check", start);
+            performance.mark("afterCheck");
+            performance.measure("Check", "beforeCheck", "afterCheck");
         }
 
         // Fully type check a source file and collect the relevant diagnostics.
@@ -17574,7 +17785,7 @@ namespace ts {
         }
 
         function getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[] {
-            const symbols: SymbolTable = {};
+            const symbols = createMap<Symbol>();
             let memberFlags: ModifierFlags = ModifierFlags.None;
 
             if (isInsideWithStatementBody(location)) {
@@ -17652,7 +17863,7 @@ namespace ts {
                     // 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
-                    if (!hasProperty(symbols, id)) {
+                    if (!symbols[id]) {
                         symbols[id] = symbol;
                     }
                 }
@@ -17740,7 +17951,7 @@ namespace ts {
             return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined;
         }
 
-        function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol {
+        function getSymbolOfEntityNameOrPropertyAccessExpression(entityName: EntityName | PropertyAccessExpression): Symbol | undefined {
             if (isDeclarationName(entityName)) {
                 return getSymbolOfNode(entityName.parent);
             }
@@ -17759,22 +17970,20 @@ namespace ts {
                 }
             }
 
-            if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
-                return resolveEntityName(<Identifier>entityName,
+            if (entityName.parent.kind === SyntaxKind.ExportAssignment && isEntityNameExpression(<Identifier | PropertyAccessExpression>entityName)) {
+                return resolveEntityName(<EntityNameExpression>entityName,
                     /*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
 
-            if (entityName.kind !== SyntaxKind.PropertyAccessExpression) {
-                if (isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
-                    // Since we already checked for ExportAssignment, this really could only be an Import
-                    const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
-                    Debug.assert(importEqualsDeclaration !== undefined);
-                    return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
-                }
+            if (entityName.kind !== SyntaxKind.PropertyAccessExpression && isInRightSideOfImportOrExportAssignment(<EntityName>entityName)) {
+                // Since we already checked for ExportAssignment, this really could only be an Import
+                const importEqualsDeclaration = <ImportEqualsDeclaration>getAncestor(entityName, SyntaxKind.ImportEqualsDeclaration);
+                Debug.assert(importEqualsDeclaration !== undefined);
+                return getSymbolOfPartOfRightHandSideOfImportEquals(<EntityName>entityName, importEqualsDeclaration, /*dontResolveAlias*/ true);
             }
 
             if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
-                entityName = <QualifiedName | PropertyAccessExpression>entityName.parent;
+                entityName = <QualifiedName | PropertyAccessEntityNameExpression>entityName.parent;
             }
 
             if (isHeritageClauseElementIdentifier(<EntityName>entityName)) {
@@ -18073,7 +18282,7 @@ namespace ts {
             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)) {
+                    if (!propsByName[p.name]) {
                         propsByName[p.name] = p;
                     }
                 });
@@ -18137,7 +18346,7 @@ namespace ts {
                 // otherwise - check if at least one export is value
                 symbolLinks.exportsSomeValue = hasExportAssignment
                     ? !!(moduleSymbol.flags & SymbolFlags.Value)
-                    : forEachValue(getExportsOfModule(moduleSymbol), isValue);
+                    : forEachProperty(getExportsOfModule(moduleSymbol), isValue);
             }
 
             return symbolLinks.exportsSomeValue;
@@ -18443,7 +18652,7 @@ namespace ts {
             else if (isTypeOfKind(type, TypeFlags.StringLike)) {
                 return TypeReferenceSerializationKind.StringLikeType;
             }
-            else if (isTypeOfKind(type, TypeFlags.Tuple)) {
+            else if (isTupleType(type)) {
                 return TypeReferenceSerializationKind.ArrayLikeType;
             }
             else if (isTypeOfKind(type, TypeFlags.ESSymbol)) {
@@ -18488,7 +18697,7 @@ namespace ts {
         }
 
         function hasGlobalName(name: string): boolean {
-            return hasProperty(globals, name);
+            return !!globals[name];
         }
 
         function getReferencedValueSymbol(reference: Identifier, startInDeclarationContainer?: boolean): Symbol {
@@ -18533,9 +18742,6 @@ namespace ts {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
                 fileToDirective = createFileMap<string>();
                 for (const key in resolvedTypeReferenceDirectives) {
-                    if (!hasProperty(resolvedTypeReferenceDirectives, key)) {
-                        continue;
-                    }
                     const resolvedDirective = resolvedTypeReferenceDirectives[key];
                     if (!resolvedDirective) {
                         continue;
@@ -18575,7 +18781,7 @@ namespace ts {
             };
 
             // defined here to avoid outer scope pollution
-            function getTypeReferenceDirectivesForEntityName(node: EntityName | PropertyAccessExpression): string[] {
+            function getTypeReferenceDirectivesForEntityName(node: EntityNameOrEntityNameExpression): string[] {
                 // program does not have any files with type reference directives - bail out
                 if (!fileToDirective) {
                     return undefined;
@@ -19376,7 +19582,7 @@ namespace ts {
         }
 
         function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) {
-            const seen: Map<SymbolFlags> = {};
+            const seen = createMap<SymbolFlags>();
             const Property = 1;
             const GetAccessor = 2;
             const SetAccessor = 4;
@@ -19440,7 +19646,7 @@ namespace ts {
                     continue;
                 }
 
-                if (!hasProperty(seen, effectiveName)) {
+                if (!seen[effectiveName]) {
                     seen[effectiveName] = currentKind;
                 }
                 else {
@@ -19464,7 +19670,7 @@ namespace ts {
         }
 
         function checkGrammarJsxElement(node: JsxOpeningLikeElement) {
-            const seen: Map<boolean> = {};
+            const seen = createMap<boolean>();
             for (const attr of node.attributes) {
                 if (attr.kind === SyntaxKind.JsxSpreadAttribute) {
                     continue;
@@ -19472,7 +19678,7 @@ namespace ts {
 
                 const jsxAttr = (<JsxAttribute>attr);
                 const name = jsxAttr.name;
-                if (!hasProperty(seen, name.text)) {
+                if (!seen[name.text]) {
                     seen[name.text] = true;
                 }
                 else {
@@ -19887,7 +20093,7 @@ namespace ts {
                 node.kind === SyntaxKind.ExportAssignment ||
                 node.kind === SyntaxKind.NamespaceExportDeclaration ||
                 getModifierFlags(node) & (ModifierFlags.Ambient | ModifierFlags.Export | ModifierFlags.Default)) {
-                return false;
+                    return false;
             }
 
             return grammarErrorOnFirstToken(node, Diagnostics.A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file);
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 6b0971d52accf..590fc13fe882f 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -62,10 +62,10 @@ namespace ts {
         },
         {
             name: "jsx",
-            type: {
+            type: createMap({
                 "preserve": JsxEmit.Preserve,
                 "react": JsxEmit.React
-            },
+            }),
             paramType: Diagnostics.KIND,
             description: Diagnostics.Specify_JSX_code_generation_Colon_preserve_or_react,
         },
@@ -92,7 +92,7 @@ namespace ts {
         {
             name: "module",
             shortName: "m",
-            type: {
+            type: createMap({
                 "none": ModuleKind.None,
                 "commonjs": ModuleKind.CommonJS,
                 "amd": ModuleKind.AMD,
@@ -100,16 +100,16 @@ namespace ts {
                 "umd": ModuleKind.UMD,
                 "es6": ModuleKind.ES6,
                 "es2015": ModuleKind.ES2015,
-            },
+            }),
             description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
             paramType: Diagnostics.KIND,
         },
         {
             name: "newLine",
-            type: {
+            type: createMap({
                 "crlf": NewLineKind.CarriageReturnLineFeed,
                 "lf": NewLineKind.LineFeed
-            },
+            }),
             description: Diagnostics.Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix,
             paramType: Diagnostics.NEWLINE,
         },
@@ -127,6 +127,10 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Do_not_emit_outputs_if_any_errors_were_reported,
         },
+        {
+            name: "noErrorTruncation",
+            type: "boolean"
+        },
         {
             name: "noImplicitAny",
             type: "boolean",
@@ -251,12 +255,12 @@ namespace ts {
         {
             name: "target",
             shortName: "t",
-            type: {
+            type: createMap({
                 "es3": ScriptTarget.ES3,
                 "es5": ScriptTarget.ES5,
                 "es6": ScriptTarget.ES6,
                 "es2015": ScriptTarget.ES2015,
-            },
+            }),
             description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015,
             paramType: Diagnostics.VERSION,
         },
@@ -285,10 +289,10 @@ namespace ts {
         },
         {
             name: "moduleResolution",
-            type: {
+            type: createMap({
                 "node": ModuleResolutionKind.NodeJs,
                 "classic": ModuleResolutionKind.Classic,
-            },
+            }),
             description: Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
         },
         {
@@ -393,7 +397,7 @@ namespace ts {
             type: "list",
             element: {
                 name: "lib",
-                type: {
+                type: createMap({
                     // JavaScript only
                     "es5": "lib.es5.d.ts",
                     "es6": "lib.es2015.d.ts",
@@ -418,7 +422,7 @@ namespace ts {
                     "es2016.array.include": "lib.es2016.array.include.d.ts",
                     "es2017.object": "lib.es2017.object.d.ts",
                     "es2017.sharedmemory": "lib.es2017.sharedmemory.d.ts"
-                },
+                }),
             },
             description: Diagnostics.Specify_library_files_to_be_included_in_the_compilation_Colon
         },
@@ -468,6 +472,14 @@ namespace ts {
         shortOptionNames: Map<string>;
     }
 
+    /* @internal */
+    export const defaultInitCompilerOptions: CompilerOptions = {
+        module: ModuleKind.CommonJS,
+        target: ScriptTarget.ES5,
+        noImplicitAny: false,
+        sourceMap: false,
+    };
+
     let optionNameMapCache: OptionNameMap;
 
     /* @internal */
@@ -476,8 +488,8 @@ namespace ts {
             return optionNameMapCache;
         }
 
-        const optionNameMap: Map<CommandLineOption> = {};
-        const shortOptionNames: Map<string> = {};
+        const optionNameMap = createMap<CommandLineOption>();
+        const shortOptionNames = createMap<string>();
         forEach(optionDeclarations, option => {
             optionNameMap[option.name.toLowerCase()] = option;
             if (option.shortName) {
@@ -492,10 +504,9 @@ namespace ts {
     /* @internal */
     export function createCompilerDiagnosticForInvalidCustomType(opt: CommandLineOptionOfCustomType): Diagnostic {
         const namesOfType: string[] = [];
-        forEachKey(opt.type, key => {
+        for (const key in opt.type) {
             namesOfType.push(` '${key}'`);
-        });
-
+        }
         return createCompilerDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);
     }
 
@@ -503,7 +514,7 @@ namespace ts {
     export function parseCustomTypeOption(opt: CommandLineOptionOfCustomType, value: string, errors: Diagnostic[]) {
         const key = trimString((value || "")).toLowerCase();
         const map = opt.type;
-        if (hasProperty(map, key)) {
+        if (key in map) {
             return map[key];
         }
         else {
@@ -557,11 +568,11 @@ namespace ts {
                     s = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();
 
                     // Try to translate short option names to their full equivalents.
-                    if (hasProperty(shortOptionNames, s)) {
+                    if (s in shortOptionNames) {
                         s = shortOptionNames[s];
                     }
 
-                    if (hasProperty(optionNameMap, s)) {
+                    if (s in optionNameMap) {
                         const opt = optionNameMap[s];
 
                         if (opt.isTSConfigOnly) {
@@ -674,6 +685,94 @@ namespace ts {
         }
     }
 
+    /**
+     * Generate tsconfig configuration when running command line "--init"
+     * @param options commandlineOptions to be generated into tsconfig.json
+     * @param fileNames array of filenames to be generated into tsconfig.json
+     */
+    /* @internal */
+    export function generateTSConfig(options: CompilerOptions, fileNames: string[]): { compilerOptions: Map<CompilerOptionsValue> } {
+        const compilerOptions = extend(options, defaultInitCompilerOptions);
+        const configurations: any = {
+            compilerOptions: serializeCompilerOptions(compilerOptions)
+        };
+        if (fileNames && fileNames.length) {
+            // only set the files property if we have at least one file
+            configurations.files = fileNames;
+        }
+
+        return configurations;
+
+        function getCustomTypeMapOfCommandLineOption(optionDefinition: CommandLineOption): Map<string | number> | undefined {
+            if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean") {
+                // this is of a type CommandLineOptionOfPrimitiveType
+                return undefined;
+            }
+            else if (optionDefinition.type === "list") {
+                return getCustomTypeMapOfCommandLineOption((<CommandLineOptionOfListType>optionDefinition).element);
+            }
+            else {
+                return (<CommandLineOptionOfCustomType>optionDefinition).type;
+            }
+        }
+
+        function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: MapLike<string | number>): string | undefined {
+            // There is a typeMap associated with this command-line option so use it to map value back to its name
+            for (const key in customTypeMap) {
+                if (customTypeMap[key] === value) {
+                    return key;
+                }
+            }
+            return undefined;
+        }
+
+        function serializeCompilerOptions(options: CompilerOptions): Map<CompilerOptionsValue> {
+            const result = createMap<CompilerOptionsValue>();
+            const optionsNameMap = getOptionNameMap().optionNameMap;
+
+            for (const name in options) {
+                if (hasProperty(options, name)) {
+                    // tsconfig only options cannot be specified via command line,
+                    // so we can assume that only types that can appear here string | number | boolean
+                    switch (name) {
+                        case "init":
+                        case "watch":
+                        case "version":
+                        case "help":
+                        case "project":
+                            break;
+                        default:
+                            const value = options[name];
+                            let optionDefinition = optionsNameMap[name.toLowerCase()];
+                            if (optionDefinition) {
+                                const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
+                                if (!customTypeMap) {
+                                    // There is no map associated with this compiler option then use the value as-is
+                                    // This is the case if the value is expect to be string, number, boolean or list of string
+                                    result[name] = value;
+                                }
+                                else {
+                                    if (optionDefinition.type === "list") {
+                                        const convertedValue: string[] = [];
+                                        for (const element of value as (string | number)[]) {
+                                            convertedValue.push(getNameOfCompilerOptionValue(element, customTypeMap));
+                                        }
+                                        result[name] = convertedValue;
+                                    }
+                                    else {
+                                        // There is a typeMap associated with this command-line option so use it to map value back to its name
+                                        result[name] = getNameOfCompilerOptionValue(value, customTypeMap);
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }
+            }
+            return result;
+        }
+    }
+
     /**
      * Remove the comments from a json like text.
      * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
@@ -817,7 +916,7 @@ namespace ts {
         const optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);
 
         for (const id in jsonOptions) {
-            if (hasProperty(optionNameMap, id)) {
+            if (id in optionNameMap) {
                 const opt = optionNameMap[id];
                 defaultOptions[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
             }
@@ -854,7 +953,7 @@ namespace ts {
 
     function convertJsonOptionOfCustomType(opt: CommandLineOptionOfCustomType, value: string, errors: Diagnostic[]) {
         const key = value.toLowerCase();
-        if (hasProperty(opt.type, key)) {
+        if (key in opt.type) {
             return opt.type[key];
         }
         else {
@@ -964,12 +1063,12 @@ namespace ts {
         // Literal file names (provided via the "files" array in tsconfig.json) are stored in a
         // file map with a possibly case insensitive key. We use this map later when when including
         // wildcard paths.
-        const literalFileMap: Map<string> = {};
+        const literalFileMap = createMap<string>();
 
         // Wildcard paths (provided via the "includes" array in tsconfig.json) are stored in a
         // file map with a possibly case insensitive key. We use this map to store paths matched
         // via wildcard, and to handle extension priority.
-        const wildcardFileMap: Map<string> = {};
+        const wildcardFileMap = createMap<string>();
 
         if (include) {
             include = validateSpecs(include, errors, /*allowTrailingRecursion*/ false);
@@ -1017,7 +1116,7 @@ namespace ts {
                 removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
 
                 const key = keyMapper(file);
-                if (!hasProperty(literalFileMap, key) && !hasProperty(wildcardFileMap, key)) {
+                if (!(key in literalFileMap) && !(key in wildcardFileMap)) {
                     wildcardFileMap[key] = file;
                 }
             }
@@ -1069,7 +1168,7 @@ namespace ts {
         //  /a/b/a?z    - Watch /a/b directly to catch any new file matching a?z
         const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
         const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
-        const wildcardDirectories: Map<WatchDirectoryFlags> = {};
+        const wildcardDirectories = createMap<WatchDirectoryFlags>();
         if (include !== undefined) {
             const recursiveKeys: string[] = [];
             for (const file of include) {
@@ -1082,7 +1181,7 @@ namespace ts {
                 if (match) {
                     const key = useCaseSensitiveFileNames ? match[0] : match[0].toLowerCase();
                     const flags = watchRecursivePattern.test(name) ? WatchDirectoryFlags.Recursive : WatchDirectoryFlags.None;
-                    const existingFlags = getProperty(wildcardDirectories, key);
+                    const existingFlags = wildcardDirectories[key];
                     if (existingFlags === undefined || existingFlags < flags) {
                         wildcardDirectories[key] = flags;
                         if (flags === WatchDirectoryFlags.Recursive) {
@@ -1094,11 +1193,9 @@ namespace ts {
 
             // Remove any subpaths under an existing recursively watched directory.
             for (const key in wildcardDirectories) {
-                if (hasProperty(wildcardDirectories, key)) {
-                    for (const recursiveKey of recursiveKeys) {
-                        if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
-                            delete wildcardDirectories[key];
-                        }
+                for (const recursiveKey of recursiveKeys) {
+                    if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
+                        delete wildcardDirectories[key];
                     }
                 }
             }
@@ -1121,7 +1218,7 @@ namespace ts {
         for (let i = ExtensionPriority.Highest; i < adjustedExtensionPriority; i++) {
             const higherPriorityExtension = extensions[i];
             const higherPriorityPath = keyMapper(changeExtension(file, higherPriorityExtension));
-            if (hasProperty(literalFiles, higherPriorityPath) || hasProperty(wildcardFiles, higherPriorityPath)) {
+            if (higherPriorityPath in literalFiles || higherPriorityPath in wildcardFiles) {
                 return true;
             }
         }
diff --git a/src/compiler/comments.ts b/src/compiler/comments.ts
index f60260a19a128..1bca13a4bdbc6 100644
--- a/src/compiler/comments.ts
+++ b/src/compiler/comments.ts
@@ -53,9 +53,8 @@ namespace ts {
                     }
                 }
                 else {
-                    let commentStart: number;
                     if (extendedDiagnostics) {
-                        commentStart = performance.mark();
+                        performance.mark("preEmitNodeWithComment");
                     }
 
                     const isEmittedNode = node.kind !== SyntaxKind.NotEmittedStatement;
@@ -88,7 +87,7 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        performance.measure("commentTime", commentStart);
+                        performance.measure("commentTime", "preEmitNodeWithComment");
                     }
 
                     if (emitFlags & NodeEmitFlags.NoNestedComments) {
@@ -99,7 +98,7 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        commentStart = performance.mark();
+                        performance.mark("beginEmitNodeWithComment");
                     }
 
                     // Restore previous container state.
@@ -114,16 +113,15 @@ namespace ts {
                     }
 
                     if (extendedDiagnostics) {
-                        performance.measure("commentTime", commentStart);
+                        performance.measure("commentTime", "beginEmitNodeWithComment");
                     }
                 }
             }
         }
 
         function emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void) {
-            let commentStart: number;
             if (extendedDiagnostics) {
-                commentStart = performance.mark();
+                performance.mark("preEmitBodyWithDetachedComments");
             }
 
             const { pos, end } = detachedRange;
@@ -136,7 +134,7 @@ namespace ts {
             }
 
             if (extendedDiagnostics) {
-                performance.measure("commentTime", commentStart);
+                performance.measure("commentTime", "preEmitBodyWithDetachedComments");
             }
 
             if (emitFlags & NodeEmitFlags.NoNestedComments) {
@@ -147,7 +145,7 @@ namespace ts {
             }
 
             if (extendedDiagnostics) {
-                commentStart = performance.mark();
+                performance.mark("beginEmitBodyWithDetachedCommetns");
             }
 
             if (!skipTrailingComments) {
@@ -155,7 +153,7 @@ namespace ts {
             }
 
             if (extendedDiagnostics) {
-                performance.measure("commentTime", commentStart);
+                performance.measure("commentTime", "beginEmitBodyWithDetachedCommetns");
             }
         }
 
@@ -227,15 +225,14 @@ namespace ts {
                 return;
             }
 
-            let commentStart: number;
             if (extendedDiagnostics) {
-                commentStart = performance.mark();
+                performance.mark("beforeEmitTrailingCommentsOfPosition");
             }
 
             forEachTrailingCommentToEmit(pos, emitTrailingCommentOfPosition);
 
             if (extendedDiagnostics) {
-                performance.measure("commentTime", commentStart);
+                performance.measure("commentTime", "beforeEmitTrailingCommentsOfPosition");
             }
         }
 
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 064f68849c6d7..e74ee64515df9 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -19,8 +19,28 @@ namespace ts {
         True = -1
     }
 
+    const createObject = Object.create;
+
+    export function createMap<T>(template?: MapLike<T>): Map<T> {
+        const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword
+
+        // Using 'delete' on an object causes V8 to put the object in dictionary mode.
+        // This disables creation of hidden classes, which are expensive when an object is
+        // constantly changing shape.
+        map["__"] = undefined;
+        delete map["__"];
+
+        // Copies keys/values from template. Note that for..in will not throw if
+        // template is undefined, and instead will just exit the loop.
+        for (const key in template) if (hasOwnProperty.call(template, key)) {
+            map[key] = template[key];
+        }
+
+        return map;
+    }
+
     export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
-        let files: Map<T> = {};
+        let files = createMap<T>();
         return {
             get,
             set,
@@ -46,7 +66,7 @@ namespace ts {
         }
 
         function contains(path: Path) {
-            return hasProperty(files, toKey(path));
+            return toKey(path) in files;
         }
 
         function remove(path: Path) {
@@ -55,7 +75,7 @@ namespace ts {
         }
 
         function clear() {
-            files = {};
+            files = createMap<T>();
         }
 
         function toKey(path: Path): string {
@@ -81,7 +101,7 @@ namespace ts {
      * returns a truthy value, then returns that value.
      * If no such value is found, the callback is applied to each element of array and undefined is returned.
      */
-    export function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
+    export function forEach<T, U>(array: T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {
         if (array) {
             for (let i = 0, len = array.length; i < len; i++) {
                 const result = callback(array[i], i);
@@ -110,6 +130,31 @@ namespace ts {
         return true;
     }
 
+    /** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */
+    export function find<T>(array: T[], predicate: (element: T, index: number) => boolean): T | undefined {
+        for (let i = 0, len = array.length; i < len; i++) {
+            const value = array[i];
+            if (predicate(value, i)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Returns the first truthy result of `callback`, or else fails.
+     * This is like `forEach`, but never returns undefined.
+     */
+    export function findMap<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
+        for (let i = 0, len = array.length; i < len; i++) {
+            const result = callback(array[i], i);
+            if (result) {
+                return result;
+            }
+        }
+        Debug.fail();
+    }
+
     export function contains<T>(array: T[], value: T): boolean {
         if (array) {
             for (const v of array) {
@@ -154,20 +199,42 @@ namespace ts {
         return count;
     }
 
-    export function filter<T, U extends T>(array: T[], f: (x: T, i: number) => x is U): U[];
-    export function filter<T>(array: T[], f: (x: T, i: number) => boolean): T[];
-    export function filter<T>(array: T[], f: (x: T, i: number) => boolean): T[] {
-        let result: T[];
+    export function filter<T, U extends T>(array: T[], f: (x: T) => x is U): U[];
+    export function filter<T>(array: T[], f: (x: T) => boolean): T[]
+    export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
         if (array) {
-            result = [];
-            for (let i = 0; i < array.length; i++) {
-                const v = array[i];
-                if (f(v, i)) {
-                    result.push(v);
+            const len = array.length;
+            let i = 0;
+            while (i < len && f(array[i])) i++;
+            if (i < len) {
+                const result = array.slice(0, i);
+                i++;
+                while (i < len) {
+                    const item = array[i];
+                    if (f(item)) {
+                        result.push(item);
+                    }
+                    i++;
                 }
+                return result;
             }
         }
-        return result;
+        return array;
+    }
+
+    export function removeWhere<T>(array: T[], f: (x: T) => boolean): boolean {
+        let outIndex = 0;
+        for (const item of array) {
+            if (!f(item)) {
+                array[outIndex] = item;
+                outIndex++;
+            }
+        }
+        if (outIndex !== array.length) {
+            array.length = outIndex;
+            return true;
+        }
+        return false;
     }
 
     export function filterMutate<T>(array: T[], f: (x: T) => boolean): void {
@@ -487,80 +554,140 @@ namespace ts {
 
     const hasOwnProperty = Object.prototype.hasOwnProperty;
 
-    export function hasProperty<T>(map: Map<T>, key: string): boolean {
+    /**
+     * Indicates whether a map-like contains an own property with the specified key.
+     *
+     * NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use
+     *       the 'in' operator.
+     *
+     * @param map A map-like.
+     * @param key A property key.
+     */
+    export function hasProperty<T>(map: MapLike<T>, key: string): boolean {
         return hasOwnProperty.call(map, key);
     }
 
-    export function getKeys<T>(map: Map<T>): string[] {
+    /**
+     * Gets the value of an owned property in a map-like.
+     *
+     * NOTE: This is intended for use only with MapLike<T> objects. For Map<T> objects, use
+     *       an indexer.
+     *
+     * @param map A map-like.
+     * @param key A property key.
+     */
+    export function getProperty<T>(map: MapLike<T>, key: string): T | undefined {
+        return hasOwnProperty.call(map, key) ? map[key] : undefined;
+    }
+
+    /**
+     * Gets the owned, enumerable property keys of a map-like.
+     *
+     * NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use
+     *       Object.keys instead as it offers better performance.
+     *
+     * @param map A map-like.
+     */
+    export function getOwnKeys<T>(map: MapLike<T>): string[] {
         const keys: string[] = [];
-        for (const key in map) {
+        for (const key in map) if (hasOwnProperty.call(map, key)) {
             keys.push(key);
         }
         return keys;
     }
 
-    export function getProperty<T>(map: Map<T>, key: string): T | undefined {
-        return hasProperty(map, key) ? map[key] : undefined;
-    }
-
-    export function getOrUpdateProperty<T>(map: Map<T>, key: string, makeValue: () => T): T {
-        return hasProperty(map, key) ? map[key] : map[key] = makeValue();
-    }
-
-    export function isEmpty<T>(map: Map<T>) {
-        for (const id in map) {
-            if (hasProperty(map, id)) {
-                return false;
-            }
+    /**
+     * Enumerates the properties of a Map<T>, invoking a callback and returning the first truthy result.
+     *
+     * @param map A map for which properties should be enumerated.
+     * @param callback A callback to invoke for each property.
+     */
+    export function forEachProperty<T, U>(map: Map<T>, callback: (value: T, key: string) => U): U {
+        let result: U;
+        for (const key in map) {
+            if (result = callback(map[key], key)) break;
         }
-        return true;
+        return result;
     }
 
-    export function clone<T>(object: T): T {
-        const result: any = {};
-        for (const id in object) {
-            result[id] = (<any>object)[id];
+    /**
+     * Returns true if a Map<T> has some matching property.
+     *
+     * @param map A map whose properties should be tested.
+     * @param predicate An optional callback used to test each property.
+     */
+    export function someProperties<T>(map: Map<T>, predicate?: (value: T, key: string) => boolean) {
+        for (const key in map) {
+            if (!predicate || predicate(map[key], key)) return true;
         }
-        return <T>result;
+        return false;
     }
 
-    export function extend<T1 extends Map<{}>, T2 extends Map<{}>>(first: T1 , second: T2): T1 & T2 {
-        const result: T1 & T2 = <any>{};
-        for (const id in first) {
-            (result as any)[id] = first[id];
-        }
-        for (const id in second) {
-            if (!hasProperty(result, id)) {
-                (result as any)[id] = second[id];
-            }
+    /**
+     * Performs a shallow copy of the properties from a source Map<T> to a target MapLike<T>
+     *
+     * @param source A map from which properties should be copied.
+     * @param target A map to which properties should be copied.
+     */
+    export function copyProperties<T>(source: Map<T>, target: MapLike<T>): void {
+        for (const key in source) {
+            target[key] = source[key];
         }
-        return result;
     }
 
-    export function forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U {
-        let result: U;
-        for (const id in map) {
-            if (result = callback(map[id])) break;
+    /**
+     * Reduce the properties of a map.
+     *
+     * NOTE: This is intended for use with Map<T> objects. For MapLike<T> objects, use
+     *       reduceOwnProperties instead as it offers better runtime safety.
+     *
+     * @param map The map to reduce
+     * @param callback An aggregation function that is called for each entry in the map
+     * @param initial The initial value for the reduction.
+     */
+    export function reduceProperties<T, U>(map: Map<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
+        let result = initial;
+        for (const key in map) {
+            result = callback(result, map[key], String(key));
         }
         return result;
     }
 
-    export function forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U {
-        let result: U;
-        for (const id in map) {
-            if (result = callback(id)) break;
+    /**
+     * Reduce the properties defined on a map-like (but not from its prototype chain).
+     *
+     * NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use
+     *       reduceProperties instead as it offers better performance.
+     *
+     * @param map The map-like to reduce
+     * @param callback An aggregation function that is called for each entry in the map
+     * @param initial The initial value for the reduction.
+     */
+    export function reduceOwnProperties<T, U>(map: MapLike<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
+        let result = initial;
+        for (const key in map) if (hasOwnProperty.call(map, key)) {
+            result = callback(result, map[key], String(key));
         }
         return result;
     }
 
-    export function lookUp<T>(map: Map<T>, key: string): T {
-        return hasProperty(map, key) ? map[key] : undefined;
-    }
-
-    export function copyMap<T>(source: Map<T>, target: Map<T>): void {
-        for (const p in source) {
-            target[p] = source[p];
+    /**
+     * Performs a shallow equality comparison of the contents of two map-likes.
+     *
+     * @param left A map-like whose properties should be compared.
+     * @param right A map-like whose properties should be compared.
+     */
+    export function equalOwnProperties<T>(left: MapLike<T>, right: MapLike<T>, equalityComparer?: (left: T, right: T) => boolean) {
+        if (left === right) return true;
+        if (!left || !right) return false;
+        for (const key in left) if (hasOwnProperty.call(left, key)) {
+            if (!hasOwnProperty.call(right, key) === undefined) return false;
+            if (equalityComparer ? !equalityComparer(left[key], right[key]) : left[key] !== right[key]) return false;
+        }
+        for (const key in right) if (hasOwnProperty.call(right, key)) {
+            if (!hasOwnProperty.call(left, key)) return false;
         }
+        return true;
     }
 
     /**
@@ -573,33 +700,49 @@ namespace ts {
      * the same key with the given 'makeKey' function, then the element with the higher
      * 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> {
-        const result: Map<T> = {};
+    export function arrayToMap<T>(array: T[], makeKey: (value: T) => string): Map<T>;
+    export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue: (value: T) => U): Map<U>;
+    export function arrayToMap<T, U>(array: T[], makeKey: (value: T) => string, makeValue?: (value: T) => U): Map<T | U> {
+        const result = createMap<T | U>();
+        for (const value of array) {
+            result[makeKey(value)] = makeValue ? makeValue(value) : value;
+        }
+        return result;
+    }
 
-        forEach(array, value => {
-            result[makeKey(value)] = value;
-        });
+    export function isEmpty<T>(map: Map<T>) {
+        for (const id in map) {
+            if (hasProperty(map, id)) {
+                return false;
+            }
+        }
+        return true;
+    }
 
-        return result;
+    export function cloneMap<T>(map: Map<T>) {
+        const clone = createMap<T>();
+        copyProperties(map, clone);
+        return clone;
     }
 
-    /**
-     * Reduce the properties of a map.
-     *
-     * @param map The map to reduce
-     * @param callback An aggregation function that is called for each entry in the map
-     * @param initial The initial value for the reduction.
-     */
-    export function reduceProperties<T, U>(map: Map<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
-        let result = initial;
-        if (map) {
-            for (const key in map) {
-                if (hasProperty(map, key)) {
-                    result = callback(result, map[key], String(key));
-                }
+    export function clone<T>(object: T): T {
+        const result: any = {};
+        for (const id in object) {
+            if (hasOwnProperty.call(object, id)) {
+                result[id] = (<any>object)[id];
             }
         }
+        return result;
+    }
 
+    export function extend<T1, T2>(first: T1 , second: T2): T1 & T2 {
+        const result: T1 & T2 = <any>{};
+        for (const id in second) if (hasOwnProperty.call(second, id)) {
+            (result as any)[id] = (second as any)[id];
+        }
+        for (const id in first) if (hasOwnProperty.call(first, id)) {
+            (result as any)[id] = (first as any)[id];
+        }
         return result;
     }
 
@@ -630,9 +773,7 @@ namespace ts {
     export let localizedDiagnosticMessages: Map<string> = undefined;
 
     export function getLocaleSpecificMessage(message: DiagnosticMessage) {
-        return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key]
-            ? localizedDiagnosticMessages[message.key]
-            : message.message;
+        return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message;
     }
 
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ...args: any[]): Diagnostic;
@@ -1368,6 +1509,8 @@ namespace ts {
      *  List of supported extensions in order of file resolution precedence.
      */
     export const supportedTypeScriptExtensions = [".ts", ".tsx", ".d.ts"];
+    /** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */
+    export const supportedTypescriptExtensionsForExtractExtension = [".d.ts", ".ts", ".tsx"];
     export const supportedJavascriptExtensions = [".js", ".jsx"];
     const allSupportedExtensions  = supportedTypeScriptExtensions.concat(supportedJavascriptExtensions);
 
@@ -1450,8 +1593,12 @@ namespace ts {
         return path;
     }
 
-    export function tryRemoveExtension(path: string, extension: string): string {
-        return fileExtensionIs(path, extension) ? path.substring(0, path.length - extension.length) : undefined;
+    export function tryRemoveExtension(path: string, extension: string): string | undefined {
+        return fileExtensionIs(path, extension) ? removeExtension(path, extension) : undefined;
+    }
+
+    export function removeExtension(path: string, extension: string): string {
+        return path.substring(0, path.length - extension.length);
     }
 
     export function isJsxOrTsxExtension(ext: string): boolean {
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index d109ad70d9c0f..dcc7ca7c1ae1b 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -157,9 +157,7 @@ namespace ts {
 
         if (usedTypeDirectiveReferences) {
             for (const directive in usedTypeDirectiveReferences) {
-                if (hasProperty(usedTypeDirectiveReferences, directive)) {
-                    referencesOutput += `/// <reference types="${directive}" />${newLine}`;
-                }
+                referencesOutput += `/// <reference types="${directive}" />${newLine}`;
             }
         }
 
@@ -269,10 +267,10 @@ namespace ts {
             }
 
             if (!usedTypeDirectiveReferences) {
-                usedTypeDirectiveReferences = {};
+                usedTypeDirectiveReferences = createMap<string>();
             }
             for (const directive of typeReferenceDirectives) {
-                if (!hasProperty(usedTypeDirectiveReferences, directive)) {
+                if (!(directive in usedTypeDirectiveReferences)) {
                     usedTypeDirectiveReferences[directive] = directive;
                 }
             }
@@ -441,7 +439,7 @@ namespace ts {
                 }
             }
 
-            function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
+            function emitEntityName(entityName: EntityNameOrEntityNameExpression) {
                 const visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
                     entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
@@ -452,9 +450,9 @@ namespace ts {
             }
 
             function emitExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
-                if (isSupportedExpressionWithTypeArguments(node)) {
+                if (isEntityNameExpression(node.expression)) {
                     Debug.assert(node.expression.kind === SyntaxKind.Identifier || node.expression.kind === SyntaxKind.PropertyAccessExpression);
-                    emitEntityName(<Identifier | PropertyAccessExpression>node.expression);
+                    emitEntityName(node.expression);
                     if (node.typeArguments) {
                         write("<");
                         emitCommaList(node.typeArguments, emitType);
@@ -537,14 +535,14 @@ namespace ts {
         // do not need to keep track of created temp names.
         function getExportDefaultTempVariableName(): string {
             const baseName = "_default";
-            if (!hasProperty(currentIdentifiers, baseName)) {
+            if (!(baseName in currentIdentifiers)) {
                 return baseName;
             }
             let count = 0;
             while (true) {
                 count++;
                 const name = baseName + "_" + count;
-                if (!hasProperty(currentIdentifiers, name)) {
+                if (!(name in currentIdentifiers)) {
                     return name;
                 }
             }
@@ -1020,7 +1018,7 @@ namespace ts {
             }
 
             function emitTypeOfTypeReference(node: ExpressionWithTypeArguments) {
-                if (isSupportedExpressionWithTypeArguments(node)) {
+                if (isEntityNameExpression(node.expression)) {
                     emitTypeWithNewGetSymbolAccessibilityDiagnostic(node, getHeritageClauseVisibilityError);
                 }
                 else if (!isImplementsList && node.expression.kind === SyntaxKind.NullKeyword) {
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 8ef0698dea723..fef175388f725 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1947,6 +1947,14 @@
         "category": "Error",
         "code": 2690
     },
+    "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead.": {
+        "category": "Error",
+        "code": 2691
+    },
+    "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible.": {
+        "category": "Error",
+        "code": 2692
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2227,7 +2235,7 @@
         "category": "Error",
         "code": 4082
     },
-    "Conflicting library definitions for '{0}' found at '{1}' and '{2}'. Copy the correct file to the 'typings' folder to resolve this conflict.": {
+    "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict.": {
         "category": "Message",
         "code": 4090
     },
@@ -2824,9 +2832,13 @@
         "category": "Message",
         "code": 6137
     },
+    "Property '{0}' is declared but never used.": {
+        "category": "Error",
+        "code": 6138
+    },
     "Import emit helpers from 'tslib'.": {
         "category": "Message",
-        "code": 6138
+        "code": 6139
     },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 8b91a7c19d944..680c446c0d53e 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -182,8 +182,7 @@ const _super = (function (geti, seti) {
         let isOwnFileEmit: boolean;
         let emitSkipped = false;
 
-        performance.emit("beforeTransform");
-        const transformStart = performance.mark();
+        performance.mark("beforeTransform");
 
         // Transform the source files
         const transformed = transformFiles(
@@ -192,8 +191,7 @@ const _super = (function (geti, seti) {
             getSourceFilesToEmit(host, targetSourceFile),
             transformers);
 
-        performance.measure("transformTime", transformStart);
-        performance.emit("afterTransform");
+        performance.measure("transformTime", "beforeTransform");
 
         // Extract helpers from the result
         const {
@@ -204,8 +202,7 @@ const _super = (function (geti, seti) {
             onEmitNode
         } = transformed;
 
-        performance.emit("beforePrint");
-        const printStart = performance.mark();
+        performance.mark("beforePrint");
 
         // Emit each output file
         forEachTransformedEmitFile(host, transformed.getSourceFiles(), emitFile);
@@ -213,8 +210,7 @@ const _super = (function (geti, seti) {
         // Clean up after transformation
         transformed.dispose();
 
-        performance.measure("printTime", printStart);
-        performance.emit("afterPrint");
+        performance.measure("printTime", "beforePrint");
 
         return {
             emitSkipped,
@@ -251,7 +247,7 @@ const _super = (function (geti, seti) {
             sourceMap.initialize(jsFilePath, sourceMapFilePath, sourceFiles, isBundledEmit);
             nodeIdToGeneratedName = [];
             autoGeneratedIdToGeneratedName = [];
-            generatedNameSet = {};
+            generatedNameSet = createMap<string>();
             isOwnFileEmit = !isBundledEmit;
 
             // Emit helpers from all the files
@@ -2609,7 +2605,7 @@ const _super = (function (geti, seti) {
 
         function getTextOfNode(node: Node, includeTrivia?: boolean): string {
             if (isGeneratedIdentifier(node)) {
-                return getGeneratedIdentifier(node);
+                return getGeneratedIdentifier(<Identifier>node);
             }
             else if (isIdentifier(node) && (nodeIsSynthesized(node) || !node.parent)) {
                 return unescapeIdentifier(node.text);
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 510360af1430b..a6cadb7772883 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -420,14 +420,16 @@ namespace ts {
                     visitNode(cbNode, (<JSDocPropertyTag>node).name);
             case SyntaxKind.PartiallyEmittedExpression:
                 return visitNode(cbNode, (<PartiallyEmittedExpression>node).expression);
+            case SyntaxKind.JSDocLiteralType:
+                    return visitNode(cbNode, (<JSDocLiteralType>node).literal);
         }
     }
 
     export function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes = false, scriptKind?: ScriptKind): SourceFile {
-        const start = performance.mark();
+        performance.mark("beforeParse");
         const result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind);
-
-        performance.measure("Parse", start);
+        performance.mark("afterParse");
+        performance.measure("Parse", "beforeParse", "afterParse");
         return result;
     }
 
@@ -598,7 +600,7 @@ namespace ts {
 
             parseDiagnostics = [];
             parsingContext = 0;
-            identifiers = {};
+            identifiers = createMap<string>();
             identifierCount = 0;
             nodeCount = 0;
 
@@ -913,7 +915,7 @@ namespace ts {
             // 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.
+            // assert that invariant holds.
             const saveContextFlags = contextFlags;
 
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
@@ -1097,7 +1099,7 @@ namespace ts {
 
         function internIdentifier(text: string): string {
             text = escapeIdentifier(text);
-            return hasProperty(identifiers, text) ? identifiers[text] : (identifiers[text] = text);
+            return identifiers[text] || (identifiers[text] = text);
         }
 
         // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues
@@ -2761,7 +2763,7 @@ namespace ts {
             // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
             // (i.e. they're both BinaryExpressions with an assignment operator in it).
 
-            // First, do the simple check if we have a YieldExpression (production '5').
+            // First, do the simple check if we have a YieldExpression (production '6').
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
@@ -3368,24 +3370,40 @@ namespace ts {
         }
 
         /**
-         * Parse ES7 unary expression and await expression
+         * Parse ES7 exponential expression and await expression
+         *
+         * ES7 ExponentiationExpression:
+         *      1) UnaryExpression[?Yield]
+         *      2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
          *
-         * ES7 UnaryExpression:
-         *      1) SimpleUnaryExpression[?yield]
-         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
          */
         function parseUnaryExpressionOrHigher(): UnaryExpression | BinaryExpression {
-            if (isAwaitExpression()) {
-                return parseAwaitExpression();
-            }
-
-            if (isIncrementExpression()) {
+            /**
+             * ES7 UpdateExpression:
+             *      1) LeftHandSideExpression[?Yield]
+             *      2) LeftHandSideExpression[?Yield][no LineTerminator here]++
+             *      3) LeftHandSideExpression[?Yield][no LineTerminator here]--
+             *      4) ++UnaryExpression[?Yield]
+             *      5) --UnaryExpression[?Yield]
+             */
+            if (isUpdateExpression()) {
                 const incrementExpression = parseIncrementExpression();
                 return token() === SyntaxKind.AsteriskAsteriskToken ?
                     <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
 
+            /**
+             * ES7 UnaryExpression:
+             *      1) UpdateExpression[?yield]
+             *      2) delete UpdateExpression[?yield]
+             *      3) void UpdateExpression[?yield]
+             *      4) typeof UpdateExpression[?yield]
+             *      5) + UpdateExpression[?yield]
+             *      6) - UpdateExpression[?yield]
+             *      7) ~ UpdateExpression[?yield]
+             *      8) ! UpdateExpression[?yield]
+             */
             const unaryOperator = token();
             const simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token() === SyntaxKind.AsteriskAsteriskToken) {
@@ -3403,8 +3421,8 @@ namespace ts {
         /**
          * Parse ES7 simple-unary expression or higher:
          *
-         * ES7 SimpleUnaryExpression:
-         *      1) IncrementExpression[?yield]
+         * ES7 UnaryExpression:
+         *      1) UpdateExpression[?yield]
          *      2) delete UnaryExpression[?yield]
          *      3) void UnaryExpression[?yield]
          *      4) typeof UnaryExpression[?yield]
@@ -3412,6 +3430,7 @@ namespace ts {
          *      6) - UnaryExpression[?yield]
          *      7) ~ UnaryExpression[?yield]
          *      8) ! UnaryExpression[?yield]
+         *      9) [+Await] await UnaryExpression[?yield]
          */
         function parseSimpleUnaryExpression(): UnaryExpression {
             switch (token()) {
@@ -3431,6 +3450,10 @@ namespace ts {
                     //  UnaryExpression (modified):
                     //      < type > UnaryExpression
                     return parseTypeAssertion();
+                case SyntaxKind.AwaitKeyword:
+                    if (isAwaitExpression()) {
+                        return parseAwaitExpression();
+                    }
                 default:
                     return parseIncrementExpression();
             }
@@ -3439,14 +3462,14 @@ namespace ts {
         /**
          * Check if the current token can possibly be an ES7 increment expression.
          *
-         * ES7 IncrementExpression:
+         * ES7 UpdateExpression:
          *      LeftHandSideExpression[?Yield]
          *      LeftHandSideExpression[?Yield][no LineTerminator here]++
          *      LeftHandSideExpression[?Yield][no LineTerminator here]--
          *      ++LeftHandSideExpression[?Yield]
          *      --LeftHandSideExpression[?Yield]
          */
-        function isIncrementExpression(): boolean {
+        function isUpdateExpression(): boolean {
             // This function is called inside parseUnaryExpression to decide
             // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
             switch (token()) {
@@ -3457,6 +3480,7 @@ namespace ts {
                 case SyntaxKind.DeleteKeyword:
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.VoidKeyword:
+                case SyntaxKind.AwaitKeyword:
                     return false;
                 case SyntaxKind.LessThanToken:
                     // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
@@ -5883,10 +5907,17 @@ namespace ts {
                     case SyntaxKind.BooleanKeyword:
                     case SyntaxKind.SymbolKeyword:
                     case SyntaxKind.VoidKeyword:
+                    case SyntaxKind.NullKeyword:
+                    case SyntaxKind.UndefinedKeyword:
+                    case SyntaxKind.NeverKeyword:
                         return parseTokenNode<JSDocType>();
+                    case SyntaxKind.StringLiteral:
+                    case SyntaxKind.NumericLiteral:
+                    case SyntaxKind.TrueKeyword:
+                    case SyntaxKind.FalseKeyword:
+                        return parseJSDocLiteralType();
                 }
 
-                // TODO (drosen): Parse string literal types in JSDoc as well.
                 return parseJSDocTypeReference();
             }
 
@@ -6063,6 +6094,12 @@ namespace ts {
                 return finishNode(result);
             }
 
+            function parseJSDocLiteralType(): JSDocLiteralType {
+                const result = <JSDocLiteralType>createNode(SyntaxKind.JSDocLiteralType);
+                result.literal = parseLiteralTypeNode();
+                return finishNode(result);
+            }
+
             function parseJSDocUnknownOrNullableType(): JSDocUnknownType | JSDocNullableType {
                 const pos = scanner.getStartPos();
                 // skip the ?
diff --git a/src/compiler/performance.ts b/src/compiler/performance.ts
index 89db876ae5e48..e8f064e81cdf3 100644
--- a/src/compiler/performance.ts
+++ b/src/compiler/performance.ts
@@ -6,104 +6,90 @@ namespace ts {
 }
 
 /*@internal*/
+/** Performance measurements for the compiler. */
 namespace ts.performance {
-    /** Performance measurements for the compiler. */
     declare const onProfilerEvent: { (markName: string): void; profiler: boolean; };
-    let profilerEvent: (markName: string) => void;
-    let counters: Map<number>;
+
+    const profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true
+            ? onProfilerEvent
+            : (markName: string) => { };
+
+    let enabled = false;
+    let profilerStart = 0;
+    let counts: Map<number>;
+    let marks: Map<number>;
     let measures: Map<number>;
 
     /**
-     * Emit a performance event if ts-profiler is connected. This is primarily used
-     * to generate heap snapshots.
+     * Marks a performance event.
      *
-     * @param eventName A name for the event.
+     * @param markName The name of the mark.
      */
-    export function emit(eventName: string) {
-        if (profilerEvent) {
-            profilerEvent(eventName);
+    export function mark(markName: string) {
+        if (enabled) {
+            marks[markName] = timestamp();
+            counts[markName] = (counts[markName] || 0) + 1;
+            profilerEvent(markName);
         }
     }
 
     /**
-     * Increments a counter with the specified name.
+     * Adds a performance measurement with the specified name.
      *
-     * @param counterName The name of the counter.
+     * @param measureName The name of the performance measurement.
+     * @param startMarkName The name of the starting mark. If not supplied, the point at which the
+     *      profiler was enabled is used.
+     * @param endMarkName The name of the ending mark. If not supplied, the current timestamp is
+     *      used.
      */
-    export function increment(counterName: string) {
-        if (counters) {
-            counters[counterName] = (getProperty(counters, counterName) || 0) + 1;
+    export function measure(measureName: string, startMarkName?: string, endMarkName?: string) {
+        if (enabled) {
+            const end = endMarkName && marks[endMarkName] || timestamp();
+            const start = startMarkName && marks[startMarkName] || profilerStart;
+            measures[measureName] = (measures[measureName] || 0) + (end - start);
         }
     }
 
     /**
-     * Gets the value of the counter with the specified name.
+     * Gets the number of times a marker was encountered.
      *
-     * @param counterName The name of the counter.
-     */
-    export function getCount(counterName: string) {
-        return counters && getProperty(counters, counterName) || 0;
-    }
-
-    /**
-     * Marks the start of a performance measurement.
+     * @param markName The name of the mark.
      */
-    export function mark() {
-        return measures ? timestamp() : 0;
+    export function getCount(markName: string) {
+        return counts && counts[markName] || 0;
     }
 
     /**
-     * Adds a performance measurement with the specified name.
+     * Gets the total duration of all measurements with the supplied name.
      *
-     * @param measureName The name of the performance measurement.
-     * @param marker The timestamp of the starting mark.
+     * @param measureName The name of the measure whose durations should be accumulated.
      */
-    export function measure(measureName: string, marker: number) {
-        if (measures) {
-            measures[measureName] = (getProperty(measures, measureName) || 0) + (timestamp() - marker);
-        }
+    export function getDuration(measureName: string) {
+        return measures && measures[measureName] || 0;
     }
 
     /**
      * Iterate over each measure, performing some action
-     * 
+     *
      * @param cb The action to perform for each measure
      */
     export function forEachMeasure(cb: (measureName: string, duration: number) => void) {
-        return forEachKey(measures, key => cb(key, measures[key]));
-    }
-
-    /**
-     * Gets the total duration of all measurements with the supplied name.
-     *
-     * @param measureName The name of the measure whose durations should be accumulated.
-     */
-    export function getDuration(measureName: string) {
-        return measures && getProperty(measures, measureName) || 0;
+        for (const key in measures) {
+            cb(key, measures[key]);
+        }
     }
 
     /** Enables (and resets) performance measurements for the compiler. */
     export function enable() {
-        counters = { };
-        measures = {
-            "I/O Read": 0,
-            "I/O Write": 0,
-            "Program": 0,
-            "Parse": 0,
-            "Bind": 0,
-            "Check": 0,
-            "Emit": 0,
-        };
-
-        profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true
-            ? onProfilerEvent
-            : undefined;
+        counts = createMap<number>();
+        marks = createMap<number>();
+        measures = createMap<number>();
+        enabled = true;
+        profilerStart = timestamp();
     }
 
-    /** Disables (and clears) performance measurements for the compiler. */
+    /** Disables performance measurements for the compiler. */
     export function disable() {
-        counters = undefined;
-        measures = undefined;
-        profilerEvent = undefined;
+        enabled = false;
     }
 }
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 58468bec62813..345081c5e8ee2 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -119,49 +119,31 @@ namespace ts {
     }
 
     function tryReadTypesSection(packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
-        let jsonContent: { typings?: string, types?: string, main?: string };
-        try {
-            const jsonText = state.host.readFile(packageJsonPath);
-            jsonContent = jsonText ? <{ typings?: string, types?: string, main?: string }>JSON.parse(jsonText) : {};
-        }
-        catch (e) {
-            // gracefully handle if readFile fails or returns not JSON
-            jsonContent = {};
-        }
-
-        let typesFile: string;
-        let fieldName: string;
-        // first try to read content of 'typings' section (backward compatibility)
-        if (jsonContent.typings) {
-            if (typeof jsonContent.typings === "string") {
-                fieldName = "typings";
-                typesFile = jsonContent.typings;
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "typings", typeof jsonContent.typings);
+        const jsonContent = readJson(packageJsonPath, state.host);
+
+        function tryReadFromField(fieldName: string) {
+            if (hasProperty(jsonContent, fieldName)) {
+                const typesFile = (<any>jsonContent)[fieldName];
+                if (typeof typesFile === "string") {
+                    const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
+                    }
+                    return typesFilePath;
                 }
-            }
-        }
-        // then read 'types'
-        if (!typesFile && jsonContent.types) {
-            if (typeof jsonContent.types === "string") {
-                fieldName = "types";
-                typesFile = jsonContent.types;
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, "types", typeof jsonContent.types);
+                else {
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, fieldName, typeof typesFile);
+                    }
                 }
             }
         }
-        if (typesFile) {
-            const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
-            }
+
+        const typesFilePath = tryReadFromField("typings") || tryReadFromField("types");
+        if (typesFilePath) {
             return typesFilePath;
         }
+
         // Use the main module for inferring types if no types package specified and the allowJs is set
         if (state.compilerOptions.allowJs && jsonContent.main && typeof jsonContent.main === "string") {
             if (state.traceEnabled) {
@@ -173,6 +155,17 @@ namespace ts {
         return undefined;
     }
 
+    function readJson(path: string, host: ModuleResolutionHost): { typings?: string, types?: string, main?: string } {
+        try {
+            const jsonText = host.readFile(path);
+            return jsonText ? JSON.parse(jsonText) : {};
+        }
+        catch (e) {
+            // gracefully handle if readFile fails or returns not JSON
+            return {};
+        }
+    }
+
     const typeReferenceExtensions = [".d.ts"];
 
     function getEffectiveTypeRoots(options: CompilerOptions, host: ModuleResolutionHost) {
@@ -508,7 +501,7 @@ namespace ts {
             if (state.traceEnabled) {
                 trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
             }
-            matchedPattern = matchPatternOrExact(getKeys(state.compilerOptions.paths), moduleName);
+            matchedPattern = matchPatternOrExact(getOwnKeys(state.compilerOptions.paths), moduleName);
         }
 
         if (matchedPattern) {
@@ -668,24 +661,27 @@ namespace ts {
      * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
      * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
      */
-    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-        // First try to keep/add an extension: importing "./foo.ts" can be matched by a file "./foo.ts", and "./foo" by "./foo.d.ts"
-        const resolvedByAddingOrKeepingExtension = loadModuleFromFileWorker(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
-        if (resolvedByAddingOrKeepingExtension) {
-            return resolvedByAddingOrKeepingExtension;
+    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        // First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts"
+        const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
+        if (resolvedByAddingExtension) {
+            return resolvedByAddingExtension;
         }
-        // Then try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one, e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
+
+        // If that didn't work, try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one;
+        // e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
         if (hasJavaScriptFileExtension(candidate)) {
             const extensionless = removeFileExtension(candidate);
             if (state.traceEnabled) {
                 const extension = candidate.substring(extensionless.length);
                 trace(state.host, Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
             }
-            return loadModuleFromFileWorker(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
+            return tryAddingExtensions(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
         }
     }
 
-    function loadModuleFromFileWorker(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
+    /** Try to return an existing file that adds one of the `extensions` to `candidate`. */
+    function tryAddingExtensions(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
         if (!onlyRecordFailures) {
             // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
             const directory = getDirectoryPath(candidate);
@@ -693,31 +689,29 @@ namespace ts {
                 onlyRecordFailures = !directoryProbablyExists(directory, state.host);
             }
         }
-        return forEach(extensions, tryLoad);
+        return forEach(extensions, ext =>
+            !(state.skipTsx && isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state));
+    }
 
-        function tryLoad(ext: string): string {
-            if (state.skipTsx && isJsxOrTsxExtension(ext)) {
-                return undefined;
-            }
-            const fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
-            if (!onlyRecordFailures && state.host.fileExists(fileName)) {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
-                }
-                return fileName;
+    /** Return the file if it exists. */
+    function tryFile(fileName: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        if (!onlyRecordFailures && state.host.fileExists(fileName)) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
             }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
-                }
-                failedLookupLocation.push(fileName);
-                return undefined;
+            return fileName;
+        }
+        else {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
             }
+            failedLookupLocation.push(fileName);
+            return undefined;
         }
     }
 
     function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-        const packageJsonPath = combinePaths(candidate, "package.json");
+        const packageJsonPath = pathToPackageJson(candidate);
         const directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, state.host);
         if (directoryExists && state.host.fileExists(packageJsonPath)) {
             if (state.traceEnabled) {
@@ -725,7 +719,10 @@ namespace ts {
             }
             const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
-                const result = loadModuleFromFile(typesFile, extensions, failedLookupLocation, !directoryProbablyExists(getDirectoryPath(typesFile), state.host), state);
+                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures, state);
                 if (result) {
                     return result;
                 }
@@ -747,6 +744,10 @@ namespace ts {
         return loadModuleFromFile(combinePaths(candidate, "index"), extensions, failedLookupLocation, !directoryExists, state);
     }
 
+    function pathToPackageJson(directory: string): string {
+        return combinePaths(directory, "package.json");
+    }
+
     function loadModuleFromNodeModulesFolder(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
         const nodeModulesFolder = combinePaths(directory, "node_modules");
         const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
@@ -831,14 +832,6 @@ namespace ts {
             : { resolvedModule: undefined, failedLookupLocations };
     }
 
-    /* @internal */
-    export const defaultInitCompilerOptions: CompilerOptions = {
-        module: ModuleKind.CommonJS,
-        target: ScriptTarget.ES5,
-        noImplicitAny: false,
-        sourceMap: false,
-    };
-
     interface OutputFingerprint {
         hash: string;
         byteOrderMark: boolean;
@@ -846,7 +839,7 @@ namespace ts {
     }
 
     export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost {
-        const existingDirectories: Map<boolean> = {};
+        const existingDirectories = createMap<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.
@@ -860,9 +853,10 @@ namespace ts {
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {
             let text: string;
             try {
-                const start = performance.mark();
+                performance.mark("beforeIORead");
                 text = sys.readFile(fileName, options.charset);
-                performance.measure("I/O Read", start);
+                performance.mark("afterIORead");
+                performance.measure("I/O Read", "beforeIORead", "afterIORead");
             }
             catch (e) {
                 if (onError) {
@@ -877,7 +871,7 @@ namespace ts {
         }
 
         function directoryExists(directoryPath: string): boolean {
-            if (hasProperty(existingDirectories, directoryPath)) {
+            if (directoryPath in existingDirectories) {
                 return true;
             }
             if (sys.directoryExists(directoryPath)) {
@@ -899,13 +893,13 @@ namespace ts {
 
         function writeFileIfUpdated(fileName: string, data: string, writeByteOrderMark: boolean): void {
             if (!outputFingerprints) {
-                outputFingerprints = {};
+                outputFingerprints = createMap<OutputFingerprint>();
             }
 
             const hash = sys.createHash(data);
             const mtimeBefore = sys.getModifiedTime(fileName);
 
-            if (mtimeBefore && hasProperty(outputFingerprints, fileName)) {
+            if (mtimeBefore && fileName in outputFingerprints) {
                 const fingerprint = outputFingerprints[fileName];
 
                 // If output has not been changed, and the file has no external modification
@@ -929,7 +923,7 @@ namespace ts {
 
         function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
             try {
-                const start = performance.mark();
+                performance.mark("beforeIOWrite");
                 ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));
 
                 if (isWatchSet(options) && sys.createHash && sys.getModifiedTime) {
@@ -939,7 +933,8 @@ namespace ts {
                     sys.writeFile(fileName, data, writeByteOrderMark);
                 }
 
-                performance.measure("I/O Write", start);
+                performance.mark("afterIOWrite");
+                performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
             }
             catch (e) {
                 if (onError) {
@@ -1041,16 +1036,11 @@ namespace ts {
             return [];
         }
         const resolutions: T[] = [];
-        const cache: Map<T> = {};
+        const cache = createMap<T>();
         for (const name of names) {
-            let result: T;
-            if (hasProperty(cache, name)) {
-                result = cache[name];
-            }
-            else {
-                result = loader(name, containingFile);
-                cache[name] = result;
-            }
+            const result = name in cache
+                ? cache[name]
+                : cache[name] = loader(name, containingFile);
             resolutions.push(result);
         }
         return resolutions;
@@ -1071,15 +1061,21 @@ namespace ts {
         }
 
         // Walk the primary type lookup locations
-        let result: string[] = [];
+        const result: string[] = [];
         if (host.directoryExists && host.getDirectories) {
             const typeRoots = getEffectiveTypeRoots(options, host);
             if (typeRoots) {
                 for (const root of typeRoots) {
                     if (host.directoryExists(root)) {
                         for (const typeDirectivePath of host.getDirectories(root)) {
-                            // Return just the type directive names
-                            result = result.concat(getBaseFileName(normalizePath(typeDirectivePath)));
+                            const normalized = normalizePath(typeDirectivePath);
+                            const packageJsonPath = pathToPackageJson(combinePaths(root, normalized));
+                            // tslint:disable-next-line:no-null-keyword
+                            const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
+                            if (!isNotNeededPackage) {
+                                // Return just the type directive names
+                                result.push(getBaseFileName(normalized));
+                            }
                         }
                     }
                 }
@@ -1096,7 +1092,7 @@ namespace ts {
         let noDiagnosticsTypeChecker: TypeChecker;
         let classifiableNames: Map<string>;
 
-        let resolvedTypeReferenceDirectives: Map<ResolvedTypeReferenceDirective> = {};
+        let resolvedTypeReferenceDirectives = createMap<ResolvedTypeReferenceDirective>();
         let fileProcessingDiagnostics = createDiagnosticCollection();
 
         // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.
@@ -1111,12 +1107,12 @@ namespace ts {
 
         // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track
         // this, as it may be imported at a shallower depth later, and then it will need its skipped imports processed.
-        const modulesWithElidedImports: Map<boolean> = {};
+        const modulesWithElidedImports = createMap<boolean>();
 
         // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled.
-        const sourceFilesFoundSearchingNodeModules: Map<boolean> = {};
+        const sourceFilesFoundSearchingNodeModules = createMap<boolean>();
 
-        const start = performance.mark();
+        performance.mark("beforeProgram");
 
         host = host || createCompilerHost(options);
 
@@ -1214,8 +1210,8 @@ namespace ts {
         };
 
         verifyCompilerOptions();
-
-        performance.measure("Program", start);
+        performance.mark("afterProgram");
+        performance.measure("Program", "beforeProgram", "afterProgram");
 
         return program;
 
@@ -1242,10 +1238,10 @@ namespace ts {
             if (!classifiableNames) {
                 // Initialize a checker so that all our files are bound.
                 getTypeChecker();
-                classifiableNames = {};
+                classifiableNames = createMap<string>();
 
                 for (const sourceFile of files) {
-                    copyMap(sourceFile.classifiableNames, classifiableNames);
+                    copyProperties(sourceFile.classifiableNames, classifiableNames);
                 }
             }
 
@@ -1273,7 +1269,7 @@ namespace ts {
                 (oldOptions.maxNodeModuleJsDepth !== options.maxNodeModuleJsDepth) ||
                 !arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||
                 !arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||
-                !mapIsEqualTo(oldOptions.paths, options.paths)) {
+                !equalOwnProperties(oldOptions.paths, options.paths)) {
                 return false;
             }
 
@@ -1395,7 +1391,7 @@ namespace ts {
                 getSourceFile: program.getSourceFile,
                 getSourceFileByPath: program.getSourceFileByPath,
                 getSourceFiles: program.getSourceFiles,
-                isSourceFileFromExternalLibrary: (file: SourceFile) => !!lookUp(sourceFilesFoundSearchingNodeModules, file.path),
+                isSourceFileFromExternalLibrary: (file: SourceFile) => !!sourceFilesFoundSearchingNodeModules[file.path],
                 writeFile: writeFileCallback || (
                     (fileName, data, writeByteOrderMark, onError, sourceFiles) => host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles)),
                 isEmitBlocked,
@@ -1458,17 +1454,15 @@ namespace ts {
             // checked is to not pass the file to getEmitResolver.
             const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
 
-            performance.emit("beforeEmit");
-            const start = performance.mark();
+            performance.mark("beforeEmit");
 
             const emitResult = emitFiles(
                 emitResolver,
                 getEmitHost(writeFileCallback),
                 sourceFile);
 
-            performance.measure("Emit", start);
-            performance.emit("afterEmit");
-
+            performance.mark("afterEmit");
+            performance.measure("Emit", "beforeEmit", "afterEmit");
             return emitResult;
         }
 
@@ -1946,7 +1940,7 @@ namespace ts {
 
                 // If the file was previously found via a node_modules search, but is now being processed as a root file,
                 // then everything it sucks in may also be marked incorrectly, and needs to be checked again.
-                if (file && lookUp(sourceFilesFoundSearchingNodeModules, file.path) && currentNodeModulesDepth == 0) {
+                if (file && sourceFilesFoundSearchingNodeModules[file.path] && currentNodeModulesDepth == 0) {
                     sourceFilesFoundSearchingNodeModules[file.path] = false;
                     if (!options.noResolve) {
                         processReferencedFiles(file, getDirectoryPath(fileName), isDefaultLib);
@@ -1957,7 +1951,7 @@ namespace ts {
                     processImportedModules(file, getDirectoryPath(fileName));
                 }
                 // See if we need to reprocess the imports due to prior skipped imports
-                else if (file && lookUp(modulesWithElidedImports, file.path)) {
+                else if (file && modulesWithElidedImports[file.path]) {
                     if (currentNodeModulesDepth < maxNodeModulesJsDepth) {
                         modulesWithElidedImports[file.path] = false;
                         processImportedModules(file, getDirectoryPath(fileName));
@@ -2024,15 +2018,17 @@ namespace ts {
         }
 
         function processTypeReferenceDirectives(file: SourceFile) {
-            const typeDirectives = map(file.typeReferenceDirectives, l => l.fileName);
+            // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
+            const typeDirectives = map(file.typeReferenceDirectives, ref => ref.fileName.toLocaleLowerCase());
             const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file.fileName);
 
             for (let i = 0; i < typeDirectives.length; i++) {
                 const ref = file.typeReferenceDirectives[i];
                 const resolvedTypeReferenceDirective = resolutions[i];
                 // store resolved type directive on the file
-                setResolvedTypeReferenceDirective(file, ref.fileName, resolvedTypeReferenceDirective);
-                processTypeReferenceDirective(ref.fileName, resolvedTypeReferenceDirective, file, ref.pos, ref.end);
+                const fileName = ref.fileName.toLocaleLowerCase();
+                setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
+                processTypeReferenceDirective(fileName, resolvedTypeReferenceDirective, file, ref.pos, ref.end);
             }
         }
 
@@ -2057,7 +2053,7 @@ namespace ts {
                         const otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName);
                         if (otherFileText !== getSourceFile(previousResolution.resolvedFileName).text) {
                             fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd,
-                                Diagnostics.Conflicting_library_definitions_for_0_found_at_1_and_2_Copy_the_correct_file_to_the_typings_folder_to_resolve_this_conflict,
+                                Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict,
                                 typeReferenceDirective,
                                 resolvedTypeReferenceDirective.resolvedFileName,
                                 previousResolution.resolvedFileName
@@ -2097,7 +2093,7 @@ namespace ts {
         function processImportedModules(file: SourceFile, basePath: string) {
             collectExternalModuleReferences(file);
             if (file.imports.length || file.moduleAugmentations.length) {
-                file.resolvedModules = {};
+                file.resolvedModules = createMap<ResolvedModule>();
                 const moduleNames = map(concatenate(file.imports, file.moduleAugmentations), getTextOfLiteral);
                 const resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(file.fileName, currentDirectory));
                 for (let i = 0; i < moduleNames.length; i++) {
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 50f569a643f43..2d07c2998e0d8 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -55,7 +55,7 @@ namespace ts {
         tryScan<T>(callback: () => T): T;
     }
 
-    const textToToken: Map<SyntaxKind> = {
+    const textToToken = createMap({
         "abstract": SyntaxKind.AbstractKeyword,
         "any": SyntaxKind.AnyKeyword,
         "as": SyntaxKind.AsKeyword,
@@ -179,7 +179,7 @@ namespace ts {
         "|=": SyntaxKind.BarEqualsToken,
         "^=": SyntaxKind.CaretEqualsToken,
         "@": SyntaxKind.AtToken,
-    };
+    });
 
     /*
         As per ECMAScript Language Specification 3th Edition, Section 7.6: Identifiers
@@ -274,9 +274,7 @@ namespace ts {
     function makeReverseMap(source: Map<number>): string[] {
         const result: string[] = [];
         for (const name in source) {
-            if (source.hasOwnProperty(name)) {
-                result[source[name]] = name;
-            }
+            result[source[name]] = name;
         }
         return result;
     }
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index 4a31fffe81e1d..eb369be39d777 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -219,6 +219,7 @@ namespace ts {
 
     function createSourceMapWriterWorker(host: EmitHost, writer: EmitTextWriter): SourceMapWriter {
         const compilerOptions = host.getCompilerOptions();
+        const extendedDiagnostics = compilerOptions.extendedDiagnostics;
         let currentSourceFile: SourceFile;
         let currentSourceText: string;
         let sourceMapDir: string; // The directory in which sourcemap will be
@@ -462,7 +463,9 @@ namespace ts {
                 return;
             }
 
-            const start = performance.mark();
+            if (extendedDiagnostics) {
+                performance.mark("beforeSourcemap");
+            }
 
             const sourceLinePos = getLineAndCharacterOfPosition(currentSourceFile, pos);
 
@@ -504,7 +507,10 @@ namespace ts {
 
             updateLastEncodedAndRecordedSpans();
 
-            performance.measure("Source Map", start);
+            if (extendedDiagnostics) {
+                performance.mark("afterSourcemap");
+                performance.measure("Source Map", "beforeSourcemap", "afterSourcemap");
+            }
         }
 
         function getStartPosPastDecorators(range: TextRange) {
@@ -782,30 +788,30 @@ namespace ts {
             getSourceMapData,
             setSourceFile,
             emitPos(pos: number): void {
-                const sourcemapStart = performance.mark();
+                 performance.mark("sourcemapStart");
                 emitPos(pos);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "sourcemapStart");
             },
             emitStart(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitStart");
                 emitStart(range, contextNode, ignoreNodeCallback, ignoreChildrenCallback, getTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitStart");
             },
             emitEnd(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitEnd");
                 emitEnd(range, contextNode, ignoreNodeCallback, ignoreChildrenCallback, getTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitEnd");
             },
             emitTokenStart(token: SyntaxKind, tokenStartPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitTokenStart");
                 tokenStartPos = emitTokenStart(token, tokenStartPos, contextNode, ignoreTokenCallback, getTokenTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitTokenStart");
                 return tokenStartPos;
             },
             emitTokenEnd(token: SyntaxKind, tokenEndPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
-                const sourcemapStart = performance.mark();
+                performance.mark("emitSourcemap:emitTokenEnd");
                 tokenEndPos = emitTokenEnd(token, tokenEndPos, contextNode, ignoreTokenCallback, getTokenTextRangeCallback);
-                performance.measure("sourceMapTime", sourcemapStart);
+                performance.measure("sourceMapTime", "emitSourcemap:emitTokenEnd");
                 return tokenEndPos;
             },
             changeEmitSourcePos,
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index b7cbd33a19f11..b4b776c498c3f 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -239,15 +239,15 @@ namespace ts {
             const useNonPollingWatchers = process.env["TSC_NONPOLLING_WATCHER"];
 
             function createWatchedFileSet() {
-                const dirWatchers: Map<DirectoryWatcher> = {};
+                const dirWatchers = createMap<DirectoryWatcher>();
                 // One file can have multiple watchers
-                const fileWatcherCallbacks: Map<FileWatcherCallback[]> = {};
+                const fileWatcherCallbacks = createMap<FileWatcherCallback[]>();
                 return { addFile, removeFile };
 
                 function reduceDirWatcherRefCountForFile(fileName: string) {
                     const dirName = getDirectoryPath(fileName);
-                    if (hasProperty(dirWatchers, dirName)) {
-                        const watcher = dirWatchers[dirName];
+                    const watcher = dirWatchers[dirName];
+                    if (watcher) {
                         watcher.referenceCount -= 1;
                         if (watcher.referenceCount <= 0) {
                             watcher.close();
@@ -257,13 +257,12 @@ namespace ts {
                 }
 
                 function addDirWatcher(dirPath: string): void {
-                    if (hasProperty(dirWatchers, dirPath)) {
-                        const watcher = dirWatchers[dirPath];
+                    let watcher = dirWatchers[dirPath];
+                    if (watcher) {
                         watcher.referenceCount += 1;
                         return;
                     }
-
-                    const watcher: DirectoryWatcher = _fs.watch(
+                    watcher = _fs.watch(
                         dirPath,
                         { persistent: true },
                         (eventName: string, relativeFileName: string) => fileEventHandler(eventName, relativeFileName, dirPath)
@@ -274,12 +273,7 @@ namespace ts {
                 }
 
                 function addFileWatcherCallback(filePath: string, callback: FileWatcherCallback): void {
-                    if (hasProperty(fileWatcherCallbacks, filePath)) {
-                        fileWatcherCallbacks[filePath].push(callback);
-                    }
-                    else {
-                        fileWatcherCallbacks[filePath] = [callback];
-                    }
+                    (fileWatcherCallbacks[filePath] || (fileWatcherCallbacks[filePath] = [])).push(callback);
                 }
 
                 function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {
@@ -295,8 +289,9 @@ namespace ts {
                 }
 
                 function removeFileWatcherCallback(filePath: string, callback: FileWatcherCallback) {
-                    if (hasProperty(fileWatcherCallbacks, filePath)) {
-                        const newCallbacks = copyListRemovingItem(callback, fileWatcherCallbacks[filePath]);
+                    const callbacks = fileWatcherCallbacks[filePath];
+                    if (callbacks) {
+                        const newCallbacks = copyListRemovingItem(callback, callbacks);
                         if (newCallbacks.length === 0) {
                             delete fileWatcherCallbacks[filePath];
                         }
@@ -312,7 +307,7 @@ namespace ts {
                         ? undefined
                         : ts.getNormalizedAbsolutePath(relativeFileName, baseDirPath);
                     // Some applications save a working file via rename operations
-                    if ((eventName === "change" || eventName === "rename") && hasProperty(fileWatcherCallbacks, fileName)) {
+                    if ((eventName === "change" || eventName === "rename") && fileWatcherCallbacks[fileName]) {
                         for (const fileCallback of fileWatcherCallbacks[fileName]) {
                             fileCallback(fileName);
                         }
@@ -443,7 +438,7 @@ namespace ts {
             }
 
             function getDirectories(path: string): string[] {
-                return filter<string>(_fs.readdirSync(path), p => fileSystemEntryExists(combinePaths(path, p), FileSystemEntryKind.Directory));
+                return filter<string>(_fs.readdirSync(path), dir => fileSystemEntryExists(combinePaths(path, dir), FileSystemEntryKind.Directory));
             }
 
             const nodeSystem: System = {
diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
index 84cd00ab79afb..6242a2f23474c 100644
--- a/src/compiler/transformer.ts
+++ b/src/compiler/transformer.ts
@@ -10,14 +10,14 @@
 
 /* @internal */
 namespace ts {
-    const moduleTransformerMap: Map<Transformer> = {
+    const moduleTransformerMap = createMap<Transformer>({
         [ModuleKind.ES6]: transformES6Module,
         [ModuleKind.System]: transformSystemModule,
         [ModuleKind.AMD]: transformModule,
         [ModuleKind.CommonJS]: transformModule,
         [ModuleKind.UMD]: transformModule,
         [ModuleKind.None]: transformModule,
-    };
+    });
 
     const enum SyntaxKindFeatureFlags {
         Substitution = 1 << 0,
@@ -206,7 +206,7 @@ namespace ts {
         const transformId = nextTransformId;
         nextTransformId++;
 
-        const tokenSourceMapRanges: Map<TextRange> = { };
+        const tokenSourceMapRanges = createMap<TextRange>();
         const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
         const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
         const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
diff --git a/src/compiler/transformers/es6.ts b/src/compiler/transformers/es6.ts
index b63df6d5d6d0a..4e994c1acb0fc 100644
--- a/src/compiler/transformers/es6.ts
+++ b/src/compiler/transformers/es6.ts
@@ -1663,7 +1663,7 @@ namespace ts {
         function visitLabeledStatement(node: LabeledStatement): VisitResult<Statement> {
             if (convertedLoopState) {
                 if (!convertedLoopState.labels) {
-                    convertedLoopState.labels = {};
+                    convertedLoopState.labels = createMap<string>();
                 }
                 convertedLoopState.labels[node.label.text] = node.label.text;
             }
@@ -1815,7 +1815,9 @@ namespace ts {
                     );
                 }
                 else {
-                    assignment.end = initializer.end;
+                    // Currently there is not way to check that assignment is binary expression of destructing assignment
+                    // so we have to cast never type to binaryExpression
+                    (<BinaryExpression>assignment).end = initializer.end;
                     statements.push(createStatement(assignment, /*location*/ moveRangeEnd(initializer, -1)));
                 }
             }
@@ -2249,13 +2251,13 @@ namespace ts {
         function setLabeledJump(state: ConvertedLoopState, isBreak: boolean, labelText: string, labelMarker: string): void {
             if (isBreak) {
                 if (!state.labeledNonLocalBreaks) {
-                    state.labeledNonLocalBreaks = {};
+                    state.labeledNonLocalBreaks = createMap<string>();
                 }
                 state.labeledNonLocalBreaks[labelText] = labelMarker;
             }
             else {
                 if (!state.labeledNonLocalContinues) {
-                    state.labeledNonLocalContinues = {};
+                    state.labeledNonLocalContinues = createMap<string>();
                 }
                 state.labeledNonLocalContinues[labelText] = labelMarker;
             }
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 1dcb2446e0b63..9a4b567cb8017 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -216,13 +216,13 @@ namespace ts {
         Endfinally = 7,
     }
 
-    const instructionNames: Map<string> = {
+    const instructionNames = createMap<string>({
         [Instruction.Return]: "return",
         [Instruction.Break]: "break",
         [Instruction.Yield]: "yield",
         [Instruction.YieldStar]: "yield*",
         [Instruction.Endfinally]: "endfinally",
-    };
+    });
 
     export function transformGenerators(context: TransformationContext) {
         const {
@@ -1912,7 +1912,7 @@ namespace ts {
         function cacheExpression(node: Expression): Identifier {
             let temp: Identifier;
             if (isGeneratedIdentifier(node)) {
-                return node;
+                return <Identifier>node;
             }
 
             temp = createTempVariable(hoistVariableDeclaration);
@@ -2060,8 +2060,8 @@ namespace ts {
             const name = declareLocal(text);
 
             if (!renamedCatchVariables) {
-                renamedCatchVariables = {};
-                renamedCatchVariableDeclarations = {};
+                renamedCatchVariables = createMap<boolean>();
+                renamedCatchVariableDeclarations = createMap<Identifier>();
                 context.enableSubstitution(SyntaxKind.Identifier);
             }
 
diff --git a/src/compiler/transformers/jsx.ts b/src/compiler/transformers/jsx.ts
index 90503d5a5f689..4bc523a262f94 100644
--- a/src/compiler/transformers/jsx.ts
+++ b/src/compiler/transformers/jsx.ts
@@ -259,7 +259,7 @@ namespace ts {
     }
 
     function createEntitiesMap(): Map<number> {
-        return {
+        return createMap<number>({
             "quot": 0x0022,
             "amp": 0x0026,
             "apos": 0x0027,
@@ -513,6 +513,6 @@ namespace ts {
             "clubs": 0x2663,
             "hearts": 0x2665,
             "diams": 0x2666
-        };
+        });
     }
 }
\ No newline at end of file
diff --git a/src/compiler/transformers/module/module.ts b/src/compiler/transformers/module/module.ts
index bf908d4dbc5f9..144420b7ae958 100644
--- a/src/compiler/transformers/module/module.ts
+++ b/src/compiler/transformers/module/module.ts
@@ -4,12 +4,12 @@
 /*@internal*/
 namespace ts {
     export function transformModule(context: TransformationContext) {
-        const transformModuleDelegates: Map<(node: SourceFile) => SourceFile> = {
+        const transformModuleDelegates = createMap<(node: SourceFile) => SourceFile>({
             [ModuleKind.None]: transformCommonJSModule,
             [ModuleKind.CommonJS]: transformCommonJSModule,
             [ModuleKind.AMD]: transformAMDModule,
             [ModuleKind.UMD]: transformUMDModule,
-        };
+        });
 
         const {
             startLexicalEnvironment,
@@ -43,7 +43,7 @@ namespace ts {
         let bindingNameExportSpecifiersMap: Map<ExportSpecifier[]>;
         // Subset of exportSpecifiers that is a binding-name.
         // This is to reduce amount of memory we have to keep around even after we done with module-transformer
-        const bindingNameExportSpecifiersForFileMap: Map<Map<ExportSpecifier[]>> = {};
+        const bindingNameExportSpecifiersForFileMap = createMap<Map<ExportSpecifier[]>>();
         let hasExportStarsToExportValues: boolean;
 
         return transformSourceFile;
@@ -667,7 +667,7 @@ namespace ts {
                 if (!exportEquals && exportSpecifiers && hasProperty(exportSpecifiers, name.text)) {
                     const sourceFileId = getOriginalNodeId(currentSourceFile);
                     if (!bindingNameExportSpecifiersForFileMap[sourceFileId]) {
-                        bindingNameExportSpecifiersForFileMap[sourceFileId] = {};
+                        bindingNameExportSpecifiersForFileMap[sourceFileId] = createMap<ExportSpecifier[]>();
                     }
                     bindingNameExportSpecifiersForFileMap[sourceFileId][name.text] = exportSpecifiers[name.text];
                     addExportMemberAssignments(resultStatements, name);
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 1f7897b760c1c..d303dd580ef75 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -1324,7 +1324,7 @@ namespace ts {
         }
 
         function collectDependencyGroups(externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[]) {
-            const groupIndices: Map<number> = {};
+            const groupIndices = createMap<number>();
             const dependencyGroups: DependencyGroup[] = [];
             for (let i = 0; i < externalImports.length; i++) {
                 const externalImport = externalImports[i];
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index f66e4d6d9980f..6390c8748859b 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -3152,7 +3152,7 @@ namespace ts {
                 context.enableSubstitution(SyntaxKind.Identifier);
 
                 // Keep track of class aliases.
-                classAliases = {};
+                classAliases = createMap<Identifier>();
             }
         }
 
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index fa2a4461b707c..f6b1f33df847b 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -127,11 +127,11 @@ namespace ts {
     const gutterSeparator = " ";
     const resetEscapeSequence = "\u001b[0m";
     const ellipsis = "...";
-    const categoryFormatMap: Map<string> = {
+    const categoryFormatMap = createMap<string>({
         [DiagnosticCategory.Warning]: yellowForegroundEscapeSequence,
         [DiagnosticCategory.Error]: redForegroundEscapeSequence,
         [DiagnosticCategory.Message]: blueForegroundEscapeSequence,
-    };
+    });
 
     function formatAndReset(text: string, formatStyle: string) {
         return formatStyle + text + resetEscapeSequence;
@@ -425,7 +425,7 @@ namespace ts {
             }
 
             // reset the cache of existing files
-            cachedExistingFiles = {};
+            cachedExistingFiles = createMap<boolean>();
 
             const compileResult = compile(rootFileNames, compilerOptions, compilerHost);
 
@@ -438,10 +438,9 @@ namespace ts {
         }
 
         function cachedFileExists(fileName: string): boolean {
-            if (hasProperty(cachedExistingFiles, fileName)) {
-                return cachedExistingFiles[fileName];
-            }
-            return cachedExistingFiles[fileName] = hostFileExists(fileName);
+            return fileName in cachedExistingFiles
+                ? cachedExistingFiles[fileName]
+                : cachedExistingFiles[fileName] = hostFileExists(fileName);
         }
 
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
@@ -704,7 +703,7 @@ namespace ts {
         const usageColumn: string[] = []; // Things like "-d, --declaration" go in here.
         const descriptionColumn: string[] = [];
 
-        const optionsDescriptionMap: Map<string[]> = {};  // Map between option.description and list of option.type if it is a kind
+        const optionsDescriptionMap = createMap<string[]>();  // Map between option.description and list of option.type if it is a kind
 
         for (let i = 0; i < optsList.length; i++) {
             const option = optsList[i];
@@ -732,9 +731,10 @@ namespace ts {
                 description = getDiagnosticText(option.description);
                 const options: string[] = [];
                 const element = (<CommandLineOptionOfListType>option).element;
-                forEachKey(<Map<number | string>>element.type, key => {
+                const typeMap = <Map<number | string>>element.type;
+                for (const key in typeMap) {
                     options.push(`'${key}'`);
-                });
+                }
                 optionsDescriptionMap[description] = options;
             }
             else {
@@ -791,68 +791,11 @@ namespace ts {
             reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), /* host */ undefined);
         }
         else {
-            const compilerOptions = extend(options, defaultInitCompilerOptions);
-            const configurations: any = {
-                compilerOptions: serializeCompilerOptions(compilerOptions)
-            };
-
-            if (fileNames && fileNames.length) {
-                // only set the files property if we have at least one file
-                configurations.files = fileNames;
-            }
-            else {
-                configurations.exclude = ["node_modules"];
-                if (compilerOptions.outDir) {
-                    configurations.exclude.push(compilerOptions.outDir);
-                }
-            }
-
-            sys.writeFile(file, JSON.stringify(configurations, undefined, 4));
+            sys.writeFile(file, JSON.stringify(generateTSConfig(options, fileNames), undefined, 4));
             reportDiagnostic(createCompilerDiagnostic(Diagnostics.Successfully_created_a_tsconfig_json_file), /* host */ undefined);
         }
 
         return;
-
-        function serializeCompilerOptions(options: CompilerOptions): Map<string | number | boolean> {
-            const result: Map<string | number | boolean> = {};
-            const optionsNameMap = getOptionNameMap().optionNameMap;
-
-            for (const name in options) {
-                if (hasProperty(options, name)) {
-                    // tsconfig only options cannot be specified via command line,
-                    // so we can assume that only types that can appear here string | number | boolean
-                    const value = <string | number | boolean>options[name];
-                    switch (name) {
-                        case "init":
-                        case "watch":
-                        case "version":
-                        case "help":
-                        case "project":
-                            break;
-                        default:
-                            let optionDefinition = optionsNameMap[name.toLowerCase()];
-                            if (optionDefinition) {
-                                if (typeof optionDefinition.type === "string") {
-                                    // string, number or boolean
-                                    result[name] = value;
-                                }
-                                else {
-                                    // Enum
-                                    const typeMap = <Map<number>>optionDefinition.type;
-                                    for (const key in typeMap) {
-                                        if (hasProperty(typeMap, key)) {
-                                            if (typeMap[key] === value)
-                                                result[name] = key;
-                                        }
-                                    }
-                                }
-                            }
-                            break;
-                    }
-                }
-            }
-            return result;
-        }
     }
 }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index fc64ba6be8b79..94aae9a2cd86e 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1,9 +1,13 @@
-
 namespace ts {
-    export interface Map<T> {
+
+    export interface MapLike<T> {
         [index: string]: T;
     }
 
+    export interface Map<T> extends MapLike<T> {
+        __mapBrand: any;
+    }
+
     // branded string type used to store absolute, normalized and canonicalized paths
     // arbitrary file name can be converted to Path via toPath function
     export type Path = string & { __pathBrand: any };
@@ -346,6 +350,10 @@ namespace ts {
         JSDocTypedefTag,
         JSDocPropertyTag,
         JSDocTypeLiteral,
+        JSDocLiteralType,
+        JSDocNullKeyword,
+        JSDocUndefinedKeyword,
+        JSDocNeverKeyword,
 
         // Synthesized list
         SyntaxList,
@@ -383,9 +391,9 @@ namespace ts {
         LastBinaryOperator = CaretEqualsToken,
         FirstNode = QualifiedName,
         FirstJSDocNode = JSDocTypeExpression,
-        LastJSDocNode = JSDocTypeLiteral,
+        LastJSDocNode = JSDocLiteralType,
         FirstJSDocTagNode = JSDocComment,
-        LastJSDocTagNode = JSDocTypeLiteral
+        LastJSDocTagNode = JSDocNeverKeyword
     }
 
     export const enum NodeFlags {
@@ -585,7 +593,7 @@ namespace ts {
     // @kind(SyntaxKind.ConstructSignature)
     export interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement { }
 
-    export type BindingName = Identifier | ObjectBindingPattern | ArrayBindingPattern;
+    export type BindingName = Identifier | BindingPattern;
 
     // @kind(SyntaxKind.VariableDeclaration)
     export interface VariableDeclaration extends Declaration {
@@ -1038,13 +1046,19 @@ namespace ts {
         multiLine?: boolean;
     }
 
+    export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
+    export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
+
     // @kind(SyntaxKind.PropertyAccessExpression)
     export interface PropertyAccessExpression extends MemberExpression, Declaration {
         expression: LeftHandSideExpression;
         name: Identifier;
     }
-
-    export type IdentifierOrPropertyAccess = Identifier | PropertyAccessExpression;
+    /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */
+    export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {
+        _propertyAccessExpressionLikeQualifiedNameBrand?: any;
+        expression: EntityNameExpression;
+    }
 
     // @kind(SyntaxKind.ElementAccessExpression)
     export interface ElementAccessExpression extends MemberExpression {
@@ -1566,6 +1580,10 @@ namespace ts {
         type: JSDocType;
     }
 
+    export interface JSDocLiteralType extends JSDocType {
+        literal: LiteralTypeNode;
+    }
+
     export type JSDocTypeReferencingNode = JSDocThisType | JSDocConstructorType | JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
 
     // @kind(SyntaxKind.JSDocRecordMember)
@@ -2108,7 +2126,7 @@ namespace ts {
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult;
-        isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
+        isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
@@ -2117,7 +2135,7 @@ namespace ts {
         moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean;
         isArgumentsLocalBinding(node: Identifier): boolean;
         getExternalModuleFileFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration | ModuleDeclaration): SourceFile;
-        getTypeReferenceDirectivesForEntityName(name: EntityName | PropertyAccessExpression): string[];
+        getTypeReferenceDirectivesForEntityName(name: EntityNameOrEntityNameExpression): string[];
         getTypeReferenceDirectivesForSymbol(symbol: Symbol, meaning?: SymbolFlags): string[];
     }
 
@@ -2224,6 +2242,8 @@ namespace ts {
         /* @internal */ exportSymbol?: Symbol;  // Exported symbol associated with this symbol
         /* @internal */ constEnumOnlyModule?: boolean; // True if module contains only const enums or other modules with only const enums
         /* @internal */ isReferenced?: boolean; // True if the symbol is referenced elsewhere
+        /* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
+        /* @internal */ isAssigned?: boolean;   // True if the symbol is a parameter with assignments
     }
 
     /* @internal */
@@ -2237,6 +2257,8 @@ namespace ts {
         mapper?: TypeMapper;                // Type mapper for instantiation alias
         referenced?: boolean;               // True if alias symbol has been referenced as a value
         containingType?: UnionOrIntersectionType; // Containing union or intersection type for synthetic property
+        hasCommonType?: boolean;            // True if constituents of synthetic property all have same type
+        isDiscriminantProperty?: boolean;   // True if discriminant synthetic property
         resolvedExports?: SymbolTable;      // Resolved exports of module
         exportsChecked?: boolean;           // True if exports of external module have been checked
         isDeclarationWithCollidingName?: boolean;    // True if symbol is block scoped redeclaration
@@ -2247,9 +2269,7 @@ namespace ts {
     /* @internal */
     export interface TransientSymbol extends Symbol, SymbolLinks { }
 
-    export interface SymbolTable {
-        [index: string]: Symbol;
-    }
+    export type SymbolTable = Map<Symbol>;
 
     /** Represents a "prefix*suffix" pattern. */
     /* @internal */
@@ -2276,23 +2296,26 @@ namespace ts {
         AsyncMethodWithSuper                = 0x00000800,  // An async method that reads a value from a member of 'super'.
         AsyncMethodWithSuperBinding         = 0x00001000,  // An async method that assigns a value to a member of 'super'.
         CaptureArguments                    = 0x00002000,  // Lexical 'arguments' used in body (for async functions)
-        EnumValuesComputed                  = 0x00004000, // Values for enum members have been computed, and any errors have been reported for them.
-        LexicalModuleMergesWithClass        = 0x00008000, // Instantiated lexical module declaration is merged with a previous class declaration.
-        LoopWithCapturedBlockScopedBinding  = 0x00010000, // Loop that contains block scoped variable captured in closure
-        CapturedBlockScopedBinding          = 0x00020000, // Block-scoped binding that is captured in some function
-        BlockScopedBindingInLoop            = 0x00040000, // Block-scoped binding with declaration nested inside iteration statement
-        ClassWithConstructorReference       = 0x00080000, // Class that contains a binding to its constructor inside of the class body.
-        ConstructorReferenceInClass         = 0x00100000, // Binding to a class constructor inside of the class's body.
-        NeedsLoopOutParameter               = 0x00200000, // Block scoped binding whose value should be explicitly copied outside of the converted loop
+        EnumValuesComputed                  = 0x00004000,  // Values for enum members have been computed, and any errors have been reported for them.
+        LexicalModuleMergesWithClass        = 0x00008000,  // Instantiated lexical module declaration is merged with a previous class declaration.
+        LoopWithCapturedBlockScopedBinding  = 0x00010000,  // Loop that contains block scoped variable captured in closure
+        CapturedBlockScopedBinding          = 0x00020000,  // Block-scoped binding that is captured in some function
+        BlockScopedBindingInLoop            = 0x00040000,  // Block-scoped binding with declaration nested inside iteration statement
+        ClassWithBodyScopedClassBinding     = 0x00080000,  // Decorated class that contains a binding to itself inside of the class body.
+        BodyScopedClassBinding              = 0x00100000,  // Binding to a decorated class inside of the class's body.
+        NeedsLoopOutParameter               = 0x00200000,  // Block scoped binding whose value should be explicitly copied outside of the converted loop
+        AssignmentsMarked                   = 0x00400000,  // Parameter assignments have been marked
+        ClassWithConstructorReference       = 0x00800000,  // Class that contains a binding to its constructor inside of the class body.
+        ConstructorReferenceInClass         = 0x01000000,  // Binding to a class constructor inside of the class's body.
     }
 
     /* @internal */
     export interface NodeLinks {
+        flags?: NodeCheckFlags;           // Set of flags specific to Node
         resolvedType?: Type;              // Cached type of type node
         resolvedSignature?: Signature;    // Cached signature of signature node or call expression
         resolvedSymbol?: Symbol;          // Cached name resolution result
         resolvedIndexInfo?: IndexInfo;    // Cached indexing info resolution result
-        flags?: NodeCheckFlags;           // Set of flags specific to Node
         enumMemberValue?: number;         // Constant value of enum member
         isVisible?: boolean;              // Is this node visible
         hasReportedStatementInAmbientContext?: boolean;  // Cache boolean if we report statements in ambient context
@@ -2322,7 +2345,7 @@ namespace ts {
         Class                   = 1 << 15,  // Class
         Interface               = 1 << 16,  // Interface
         Reference               = 1 << 17,  // Generic type reference
-        Tuple                   = 1 << 18,  // Tuple
+        Tuple                   = 1 << 18,  // Synthesized generic tuple type
         Union                   = 1 << 19,  // Union (T | U)
         Intersection            = 1 << 20,  // Intersection (T & U)
         Anonymous               = 1 << 21,  // Anonymous
@@ -2444,10 +2467,6 @@ namespace ts {
         instantiations: Map<TypeReference>;   // Generic instantiation cache
     }
 
-    export interface TupleType extends ObjectType {
-        elementTypes: Type[];  // Element types
-    }
-
     export interface UnionOrIntersectionType extends Type {
         types: Type[];                    // Constituent types
         /* @internal */
@@ -2632,7 +2651,7 @@ namespace ts {
     }
 
     export type RootPaths = string[];
-    export type PathSubstitutions = Map<string[]>;
+    export type PathSubstitutions = MapLike<string[]>;
     export type TsConfigOnlyOptions = RootPaths | PathSubstitutions;
 
     export type CompilerOptionsValue = string | number | boolean | (string | number)[] | TsConfigOnlyOptions;
@@ -2793,7 +2812,7 @@ namespace ts {
         fileNames: string[];
         raw?: any;
         errors: Diagnostic[];
-        wildcardDirectories?: Map<WatchDirectoryFlags>;
+        wildcardDirectories?: MapLike<WatchDirectoryFlags>;
     }
 
     export const enum WatchDirectoryFlags {
@@ -2803,7 +2822,7 @@ namespace ts {
 
     export interface ExpandResult {
         fileNames: string[];
-        wildcardDirectories: Map<WatchDirectoryFlags>;
+        wildcardDirectories: MapLike<WatchDirectoryFlags>;
     }
 
     /* @internal */
@@ -2825,7 +2844,7 @@ namespace ts {
 
     /* @internal */
     export interface CommandLineOptionOfCustomType extends CommandLineOptionBase {
-        type: Map<number | string>;             // an object literal mapping named values to actual values
+        type: Map<number | string>;  // an object literal mapping named values to actual values
     }
 
     /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index a5848668bf0f0..030a3a33871ad 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -83,25 +83,6 @@ namespace ts {
         return node.end - node.pos;
     }
 
-    export function mapIsEqualTo<T>(map1: Map<T>, map2: Map<T>): boolean {
-        if (!map1 || !map2) {
-            return map1 === map2;
-        }
-        return containsAll(map1, map2) && containsAll(map2, map1);
-    }
-
-    function containsAll<T>(map: Map<T>, other: Map<T>): boolean {
-        for (const key in map) {
-            if (!hasProperty(map, key)) {
-                continue;
-            }
-            if (!hasProperty(other, key) || map[key] !== other[key]) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     export function arrayIsEqualTo<T>(array1: T[], array2: T[], equaler?: (a: T, b: T) => boolean): boolean {
         if (!array1 || !array2) {
             return array1 === array2;
@@ -122,7 +103,7 @@ namespace ts {
     }
 
     export function hasResolvedModule(sourceFile: SourceFile, moduleNameText: string): boolean {
-        return sourceFile && sourceFile.resolvedModules && hasProperty(sourceFile.resolvedModules, moduleNameText);
+        return !!(sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules[moduleNameText]);
     }
 
     export function getResolvedModule(sourceFile: SourceFile, moduleNameText: string): ResolvedModule {
@@ -131,7 +112,7 @@ namespace ts {
 
     export function setResolvedModule(sourceFile: SourceFile, moduleNameText: string, resolvedModule: ResolvedModule): void {
         if (!sourceFile.resolvedModules) {
-            sourceFile.resolvedModules = {};
+            sourceFile.resolvedModules = createMap<ResolvedModule>();
         }
 
         sourceFile.resolvedModules[moduleNameText] = resolvedModule;
@@ -139,7 +120,7 @@ namespace ts {
 
     export function setResolvedTypeReferenceDirective(sourceFile: SourceFile, typeReferenceDirectiveName: string, resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective): void {
         if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
-            sourceFile.resolvedTypeReferenceDirectiveNames = {};
+            sourceFile.resolvedTypeReferenceDirectiveNames = createMap<ResolvedTypeReferenceDirective>();
         }
 
         sourceFile.resolvedTypeReferenceDirectiveNames[typeReferenceDirectiveName] = resolvedTypeReferenceDirective;
@@ -162,7 +143,7 @@ namespace ts {
         }
         for (let i = 0; i < names.length; i++) {
             const newResolution = newResolutions[i];
-            const oldResolution = oldResolutions && hasProperty(oldResolutions, names[i]) ? oldResolutions[names[i]] : undefined;
+            const oldResolution = oldResolutions && oldResolutions[names[i]];
             const changed =
                 oldResolution
                     ? !newResolution || !comparer(oldResolution, newResolution)
@@ -320,6 +301,10 @@ namespace ts {
         return node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode;
     }
 
+    export function isJSDocTag(node: Node) {
+        return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;
+    }
+
     export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
         if (nodeIsMissing(node) || !node.decorators) {
             return getTokenPosOfNode(node, sourceFile);
@@ -1118,23 +1103,14 @@ namespace ts {
             && (<PropertyAccessExpression | ElementAccessExpression>node).expression.kind === SyntaxKind.SuperKeyword;
     }
 
-    export function isSuperPropertyCall(node: Node): node is CallExpression {
-        return node.kind === SyntaxKind.CallExpression
-            && <boolean>isSuperProperty((<CallExpression>node).expression);
-    }
-
-    export function isSuperCall(node: Node): node is CallExpression {
-        return node.kind === SyntaxKind.CallExpression
-            && (<CallExpression>node).expression.kind === SyntaxKind.SuperKeyword;
-    }
-
-    export function getEntityNameFromTypeNode(node: TypeNode): EntityName | Expression {
+    export function getEntityNameFromTypeNode(node: TypeNode): EntityNameOrEntityNameExpression {
         if (node) {
             switch (node.kind) {
                 case SyntaxKind.TypeReference:
                     return (<TypeReferenceNode>node).typeName;
                 case SyntaxKind.ExpressionWithTypeArguments:
-                    return (<ExpressionWithTypeArguments>node).expression;
+                    Debug.assert(isEntityNameExpression((<ExpressionWithTypeArguments>node).expression));
+                    return <EntityNameExpression>(<ExpressionWithTypeArguments>node).expression;
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
                     return (<EntityName><Node>node);
@@ -1716,8 +1692,8 @@ namespace ts {
     // import * as <symbol> from ...
     // import { x as <symbol> } from ...
     // export { x as <symbol> } from ...
-    // export = ...
-    // export default ...
+    // export = <EntityNameExpression>
+    // export default <EntityNameExpression>
     export function isAliasSymbolDeclaration(node: Node): boolean {
         return node.kind === SyntaxKind.ImportEqualsDeclaration ||
             node.kind === SyntaxKind.NamespaceExportDeclaration ||
@@ -1725,7 +1701,11 @@ namespace ts {
             node.kind === SyntaxKind.NamespaceImport ||
             node.kind === SyntaxKind.ImportSpecifier ||
             node.kind === SyntaxKind.ExportSpecifier ||
-            node.kind === SyntaxKind.ExportAssignment && (<ExportAssignment>node).expression.kind === SyntaxKind.Identifier;
+            node.kind === SyntaxKind.ExportAssignment && exportAssignmentIsAlias(<ExportAssignment>node);
+    }
+
+    export function exportAssignmentIsAlias(node: ExportAssignment): boolean {
+        return isEntityNameExpression(node.expression);
     }
 
     export function getClassExtendsHeritageClauseElement(node: ClassLikeDeclaration | InterfaceDeclaration) {
@@ -2043,7 +2023,6 @@ namespace ts {
                         return Associativity.Right;
                 }
         }
-
         return Associativity.Left;
     }
 
@@ -2198,7 +2177,7 @@ namespace ts {
 
     export function createDiagnosticCollection(): DiagnosticCollection {
         let nonFileDiagnostics: Diagnostic[] = [];
-        const fileDiagnostics: Map<Diagnostic[]> = {};
+        const fileDiagnostics = createMap<Diagnostic[]>();
 
         let diagnosticsModified = false;
         let modificationCount = 0;
@@ -2262,9 +2241,7 @@ namespace ts {
             forEach(nonFileDiagnostics, pushDiagnostic);
 
             for (const key in fileDiagnostics) {
-                if (hasProperty(fileDiagnostics, key)) {
-                    forEach(fileDiagnostics[key], pushDiagnostic);
-                }
+                forEach(fileDiagnostics[key], pushDiagnostic);
             }
 
             return sortAndDeduplicateDiagnostics(allDiagnostics);
@@ -2279,9 +2256,7 @@ namespace ts {
             nonFileDiagnostics = sortAndDeduplicateDiagnostics(nonFileDiagnostics);
 
             for (const key in fileDiagnostics) {
-                if (hasProperty(fileDiagnostics, key)) {
-                    fileDiagnostics[key] = sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
-                }
+                fileDiagnostics[key] = sortAndDeduplicateDiagnostics(fileDiagnostics[key]);
             }
         }
     }
@@ -2292,7 +2267,7 @@ namespace ts {
     // 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.
     const escapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    const escapedCharsMap: Map<string> = {
+    const escapedCharsMap = createMap({
         "\0": "\\0",
         "\t": "\\t",
         "\v": "\\v",
@@ -2305,7 +2280,7 @@ namespace ts {
         "\u2028": "\\u2028", // lineSeparator
         "\u2029": "\\u2029", // paragraphSeparator
         "\u0085": "\\u0085"  // nextLine
-    };
+    });
 
 
     /**
@@ -3083,6 +3058,11 @@ namespace ts {
         }
     }
 
+    export function isEntityNameExpression(node: Expression): node is EntityNameExpression {
+        return node.kind === SyntaxKind.Identifier ||
+            node.kind === SyntaxKind.PropertyAccessExpression && isEntityNameExpression((<PropertyAccessExpression>node).expression);
+    }
+
     export function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
         return (node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node) ||
             (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
@@ -3111,6 +3091,11 @@ namespace ts {
         return forEach(supportedTypeScriptExtensions, extension => fileExtensionIs(fileName, extension));
     }
 
+    /** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */
+    export function tryExtractTypeScriptExtension(fileName: string): string | undefined {
+        return find(supportedTypescriptExtensionsForExtractExtension, extension => fileExtensionIs(fileName, extension));
+    }
+
     /**
      * Replace each instance of non-ascii characters by one, two, three, or four escape sequences
      * representing the UTF-8 encoding of the character, and return the expanded char code list.
@@ -3190,7 +3175,7 @@ namespace ts {
     }
 
     function stringifyObject(value: any) {
-        return `{${reduceProperties(value, stringifyProperty, "")}}`;
+        return `{${reduceOwnProperties(value, stringifyProperty, "")}}`;
     }
 
     function stringifyProperty(memo: string, value: any, key: string) {
@@ -3332,7 +3317,7 @@ namespace ts {
         return false;
     }
 
-    const syntaxKindCache: Map<string> = {};
+    const syntaxKindCache = createMap<string>();
 
     export function formatSyntaxKind(kind: SyntaxKind): string {
         const syntaxKindEnum = (<any>ts).SyntaxKind;
@@ -3480,7 +3465,7 @@ namespace ts {
 
     export function collectExternalModuleInfo(sourceFile: SourceFile, resolver: EmitResolver) {
         const externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[] = [];
-        const exportSpecifiers: Map<ExportSpecifier[]> = {};
+        const exportSpecifiers = createMap<ExportSpecifier[]>();
         let exportEquals: ExportAssignment = undefined;
         let hasExportStarsToExportValues = false;
         for (const node of sourceFile.statements) {
@@ -3521,7 +3506,7 @@ namespace ts {
                         // export { x, y }
                         for (const specifier of (<ExportDeclaration>node).exportClause.elements) {
                             const name = (specifier.propertyName || specifier.name).text;
-                            getOrUpdateProperty(exportSpecifiers, name, () => []).push(specifier);
+                            (exportSpecifiers[name] || (exportSpecifiers[name] = [])).push(specifier);
                         }
                     }
                     break;
@@ -3623,7 +3608,7 @@ namespace ts {
         return node.kind === SyntaxKind.Identifier;
     }
 
-    export function isGeneratedIdentifier(node: Node): node is Identifier {
+    export function isGeneratedIdentifier(node: Node): boolean {
         // Using `>` here catches both `GeneratedIdentifierKind.None` and `undefined`.
         return isIdentifier(node) && node.autoGenerateKind > GeneratedIdentifierKind.None;
     }
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 8e6e2ec27652e..648fd235c44d1 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -46,7 +46,7 @@ namespace ts {
      *       supplant the existing `forEachChild` implementation if performance is not
      *       significantly impacted.
      */
-    const nodeEdgeTraversalMap: Map<NodeTraversalPath> = {
+    const nodeEdgeTraversalMap = createMap<NodeTraversalPath>({
         [SyntaxKind.QualifiedName]: [
             { name: "left", test: isEntityName },
             { name: "right", test: isIdentifier }
@@ -93,7 +93,7 @@ namespace ts {
             { name: "name", test: isPropertyName },
             { name: "initializer", test: isExpression, optional: true, parenthesize: parenthesizeExpressionForList }
         ]
-    };
+    });
 
     function reduceNode<T>(node: Node, f: (memo: T, node: Node) => T, initial: T) {
         return node ? f(initial, node) : initial;
@@ -523,7 +523,7 @@ namespace ts {
                 const edgeTraversalPath = nodeEdgeTraversalMap[kind];
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
-                        const value = (<Map<any>>node)[edge.name];
+                        const value = (<MapLike<any>>node)[edge.name];
                         if (value !== undefined) {
                             result = isArray(value)
                                 ? reduceLeft(<NodeArray<Node>>value, f, result)
@@ -1140,7 +1140,7 @@ namespace ts {
                     visitNode((<PartiallyEmittedExpression>node).expression, visitor, isExpression));
 
             default:
-                let updated: Node & Map<any>;
+                let updated: Node & MapLike<any>;
                 const edgeTraversalPath = nodeEdgeTraversalMap[kind];
                 if (edgeTraversalPath) {
                     for (const edge of edgeTraversalPath) {
diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts
index 6e0c27a7ffd13..63e01f0f81483 100644
--- a/src/harness/compilerRunner.ts
+++ b/src/harness/compilerRunner.ts
@@ -1,8 +1,6 @@
 /// <reference path="harness.ts" />
 /// <reference path="runnerbase.ts" />
 /// <reference path="typeWriter.ts" />
-// In harness baselines, null is different than undefined. See `generateActual` in `harness.ts`.
-/* tslint:disable:no-null-keyword */
 
 const enum CompilerTestType {
     Conformance,
@@ -52,7 +50,7 @@ class CompilerBaselineRunner extends RunnerBase {
     private makeUnitName(name: string, root: string) {
         const path = ts.toPath(name, root, (fileName) => Harness.Compiler.getCanonicalFileName(fileName));
         const pathStart = ts.toPath(Harness.IO.getCurrentDirectory(), "", (fileName) => Harness.Compiler.getCanonicalFileName(fileName));
-        return path.replace(pathStart, "/");
+        return pathStart ? path.replace(pathStart, "/") : path;
     };
 
     public checkTestCodeOutput(fileName: string) {
@@ -136,27 +134,16 @@ class CompilerBaselineRunner extends RunnerBase {
                 otherFiles = undefined;
             });
 
-            function getByteOrderMarkText(file: Harness.Compiler.GeneratedFile): string {
-                return file.writeByteOrderMark ? "\u00EF\u00BB\u00BF" : "";
-            }
-
-            function getErrorBaseline(toBeCompiled: Harness.Compiler.TestFile[], otherFiles: Harness.Compiler.TestFile[], result: Harness.Compiler.CompilerResult) {
-                return Harness.Compiler.getErrorBaseline(toBeCompiled.concat(otherFiles), result.errors);
-            }
-
             // check errors
             it("Correct errors for " + fileName, () => {
                 if (this.errors) {
-                    Harness.Baseline.runBaseline("Correct errors for " + fileName, justName.replace(/\.tsx?$/, ".errors.txt"), (): string => {
-                        if (result.errors.length === 0) return null;
-                        return getErrorBaseline(toBeCompiled, otherFiles, result);
-                    });
+                    Harness.Compiler.doErrorBaseline(justName, toBeCompiled.concat(otherFiles), result.errors);
                 }
             });
 
             it (`Correct module resolution tracing for ${fileName}`, () => {
                 if (options.traceResolution) {
-                    Harness.Baseline.runBaseline("Correct module resolution tracing for " + fileName, justName.replace(/\.tsx?$/, ".trace.json"), () => {
+                    Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".trace.json"), () => {
                         return JSON.stringify(result.traceResults || [], undefined, 4);
                     });
                 }
@@ -165,11 +152,13 @@ class CompilerBaselineRunner extends RunnerBase {
             // Source maps?
             it("Correct sourcemap content for " + fileName, () => {
                 if (options.sourceMap || options.inlineSourceMap) {
-                    Harness.Baseline.runBaseline("Correct sourcemap content for " + fileName, justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
+                    Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
                         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.
+                            // Because of the noEmitOnError option no files are created. We need to return null because baselining isn't required.
+                            /* tslint:disable:no-null-keyword */
                             return null;
+                            /* tslint:enable:no-null-keyword */
                         }
                         return record;
                     });
@@ -178,87 +167,12 @@ class CompilerBaselineRunner extends RunnerBase {
 
             it("Correct JS output for " + fileName, () => {
                 if (hasNonDtsFiles && this.emit) {
-                    if (!options.noEmit && result.files.length === 0 && result.errors.length === 0) {
-                        throw new Error("Expected at least one js file to be emitted or at least one error to be created.");
-                    }
-
-                    // check js output
-                    Harness.Baseline.runBaseline("Correct JS output for " + fileName, justName.replace(/\.tsx?/, ".js"), () => {
-                        let tsCode = "";
-                        const tsSources = otherFiles.concat(toBeCompiled);
-                        if (tsSources.length > 1) {
-                            tsCode += "//// [" + fileName + "] ////\r\n\r\n";
-                        }
-                        for (let i = 0; i < tsSources.length; i++) {
-                            tsCode += "//// [" + Harness.Path.getFileName(tsSources[i].unitName) + "]\r\n";
-                            tsCode += tsSources[i].content + (i < (tsSources.length - 1) ? "\r\n" : "");
-                        }
-
-                        let jsCode = "";
-                        for (let i = 0; i < result.files.length; i++) {
-                            jsCode += "//// [" + Harness.Path.getFileName(result.files[i].fileName) + "]\r\n";
-                            jsCode += getByteOrderMarkText(result.files[i]);
-                            jsCode += result.files[i].code;
-                        }
-
-                        if (result.declFilesCode.length > 0) {
-                            jsCode += "\r\n\r\n";
-                            for (let i = 0; i < result.declFilesCode.length; i++) {
-                                jsCode += "//// [" + Harness.Path.getFileName(result.declFilesCode[i].fileName) + "]\r\n";
-                                jsCode += getByteOrderMarkText(result.declFilesCode[i]);
-                                jsCode += result.declFilesCode[i].code;
-                            }
-                        }
-
-                        const declFileCompilationResult =
-                            Harness.Compiler.compileDeclarationFiles(
-                                toBeCompiled, otherFiles, result, harnessSettings, options, /*currentDirectory*/ undefined);
-
-                        if (declFileCompilationResult && declFileCompilationResult.declResult.errors.length) {
-                            jsCode += "\r\n\r\n//// [DtsFileErrors]\r\n";
-                            jsCode += "\r\n\r\n";
-                            jsCode += getErrorBaseline(declFileCompilationResult.declInputFiles, declFileCompilationResult.declOtherFiles, declFileCompilationResult.declResult);
-                        }
-
-                        if (jsCode.length > 0) {
-                            return tsCode + "\r\n\r\n" + jsCode;
-                        }
-                        else {
-                            return null;
-                        }
-                    });
+                    Harness.Compiler.doJsEmitBaseline(justName, fileName, options, result, toBeCompiled, otherFiles, harnessSettings);
                 }
             });
 
             it("Correct Sourcemap output for " + fileName, () => {
-                if (options.inlineSourceMap) {
-                    if (result.sourceMaps.length > 0) {
-                        throw new Error("No sourcemap files should be generated if inlineSourceMaps was set.");
-                    }
-                    return null;
-                }
-                else if (options.sourceMap) {
-                    if (result.sourceMaps.length !== result.files.length) {
-                        throw new Error("Number of sourcemap files should be same as js files.");
-                    }
-
-                    Harness.Baseline.runBaseline("Correct Sourcemap output for " + fileName, justName.replace(/\.tsx?/, ".js.map"), () => {
-                        if ((options.noEmitOnError && result.errors.length !== 0) || result.sourceMaps.length === 0) {
-                            // We need to return null here or the runBaseLine will actually create a empty file.
-                            // Baselining isn't required here because there is no output.
-                            return null;
-                        }
-
-                        let sourceMapCode = "";
-                        for (let i = 0; i < result.sourceMaps.length; i++) {
-                            sourceMapCode += "//// [" + Harness.Path.getFileName(result.sourceMaps[i].fileName) + "]\r\n";
-                            sourceMapCode += getByteOrderMarkText(result.sourceMaps[i]);
-                            sourceMapCode += result.sourceMaps[i].code;
-                        }
-
-                        return sourceMapCode;
-                    });
-                }
+                Harness.Compiler.doSourcemapBaseline(justName, options, result);
             });
 
             it("Correct type/symbol baselines for " + fileName, () => {
@@ -266,129 +180,7 @@ class CompilerBaselineRunner extends RunnerBase {
                     return;
                 }
 
-                // NEWTODO: Type baselines
-                if (result.errors.length !== 0) {
-                    return;
-                }
-
-                // The full walker simulates the types that you would get from doing a full
-                // compile.  The pull walker simulates the types you get when you just do
-                // a type query for a random node (like how the LS would do it).  Most of the
-                // time, these will be the same.  However, occasionally, they can be different.
-                // Specifically, when the compiler internally depends on symbol IDs to order
-                // things, then we may see different results because symbols can be created in a
-                // different order with 'pull' operations, and thus can produce slightly differing
-                // output.
-                //
-                // For example, with a full type check, we may see a type displayed as: number | string
-                // But with a pull type check, we may see it as:                        string | number
-                //
-                // These types are equivalent, but depend on what order the compiler observed
-                // certain parts of the program.
-
-                const program = result.program;
-                const allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
-
-                const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true);
-
-                const fullResults: ts.Map<TypeWriterResult[]> = {};
-                const pullResults: ts.Map<TypeWriterResult[]> = {};
-
-                for (const sourceFile of allFiles) {
-                    fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
-                    pullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
-                }
-
-                // Produce baselines.  The first gives the types for all expressions.
-                // The second gives symbols for all identifiers.
-                let e1: Error, e2: Error;
-                try {
-                    checkBaseLines(/*isSymbolBaseLine*/ false);
-                }
-                catch (e) {
-                    e1 = e;
-                }
-
-                try {
-                    checkBaseLines(/*isSymbolBaseLine*/ true);
-                }
-                catch (e) {
-                    e2 = e;
-                }
-
-                if (e1 || e2) {
-                    throw e1 || e2;
-                }
-
-                return;
-
-                function checkBaseLines(isSymbolBaseLine: boolean) {
-                    const fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
-                    const pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
-
-                    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);
-                        Harness.Baseline.runBaseline("Correct pull information for " + fileName, justName.replace(/\.tsx?/, pullExtension), () => pullBaseLine);
-                    }
-                    else {
-                        Harness.Baseline.runBaseline("Correct information for " + fileName, justName.replace(/\.tsx?/, fullExtension), () => fullBaseLine);
-                    }
-                }
-
-                function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
-                    const typeLines: string[] = [];
-                    const typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
-
-                    allFiles.forEach(file => {
-                        const codeLines = file.content.split("\n");
-                        typeWriterResults[file.unitName].forEach(result => {
-                            if (isSymbolBaseline && !result.symbol) {
-                                return;
-                            }
-
-                            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];
-                            const existingTypeInfo = typeMap[file.unitName][result.line];
-                            if (existingTypeInfo) {
-                                typeInfo = existingTypeInfo.concat(typeInfo);
-                            }
-                            typeMap[file.unitName][result.line] = typeInfo;
-                        });
-
-                        typeLines.push("=== " + file.unitName + " ===\r\n");
-                        for (let i = 0; i < codeLines.length; i++) {
-                            const currentCodeLine = codeLines[i];
-                            typeLines.push(currentCodeLine + "\r\n");
-                            if (typeMap[file.unitName]) {
-                                const typeInfo = typeMap[file.unitName][i];
-                                if (typeInfo) {
-                                    typeInfo.forEach(ty => {
-                                        typeLines.push(">" + ty + "\r\n");
-                                    });
-                                    if (i + 1 < codeLines.length && (codeLines[i + 1].match(/^\s*[{|}]\s*$/) || codeLines[i + 1].trim() === "")) {
-                                    }
-                                    else {
-                                        typeLines.push("\r\n");
-                                    }
-                                }
-                            }
-                            else {
-                                typeLines.push("No type information for this code.");
-                            }
-                        }
-                    });
-
-                    return typeLines.join("");
-                }
-
+                Harness.Compiler.doTypeAndSymbolBaseline(justName, result, toBeCompiled.concat(otherFiles).filter(file => !!result.program.getSourceFile(file.unitName)));
             });
         });
     }
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index a42abbbc60909..63731417f480a 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -95,14 +95,14 @@ namespace FourSlash {
 
     export import IndentStyle = ts.IndentStyle;
 
-    const entityMap: ts.Map<string> = {
+    const entityMap = ts.createMap({
         "&": "&amp;",
         "\"": "&quot;",
         "'": "&#39;",
         "/": "&#47;",
         "<": "&lt;",
         ">": "&gt;"
-    };
+    });
 
     export function escapeXmlAttributeValue(s: string) {
         return s.replace(/[&<>"'\/]/g, ch => entityMap[ch]);
@@ -204,7 +204,7 @@ namespace FourSlash {
 
         public formatCodeOptions: ts.FormatCodeOptions;
 
-        private inputFiles: ts.Map<string> = {};  // Map between inputFile's fileName and its content for easily looking up when resolving references
+        private inputFiles = ts.createMap<string>();  // Map between inputFile's fileName and its content for easily looking up when resolving references
 
         // Add input file which has matched file name with the given reference-file path.
         // This is necessary when resolveReference flag is specified
@@ -249,6 +249,7 @@ namespace FourSlash {
             if (compilationOptions.typeRoots) {
                 compilationOptions.typeRoots = compilationOptions.typeRoots.map(p => ts.getNormalizedAbsolutePath(p, this.basePath));
             }
+            compilationOptions.skipDefaultLibCheck = true;
 
             const languageServiceAdapter = this.getLanguageServiceAdapter(testType, this.cancellationToken, compilationOptions);
             this.languageServiceAdapterHost = languageServiceAdapter.getHost();
@@ -300,11 +301,11 @@ namespace FourSlash {
             }
             else {
                 // resolveReference file-option is not specified then do not resolve any files and include all inputFiles
-                ts.forEachKey(this.inputFiles, fileName => {
+                for (const fileName in this.inputFiles) {
                     if (!Harness.isDefaultLibraryFile(fileName)) {
                         this.languageServiceAdapterHost.addScript(fileName, this.inputFiles[fileName], /*isRootFile*/ true);
                     }
-                });
+                }
                 this.languageServiceAdapterHost.addScript(Harness.Compiler.defaultLibFileName,
                     Harness.Compiler.getDefaultLibrarySourceFile().text, /*isRootFile*/ false);
             }
@@ -376,7 +377,7 @@ namespace FourSlash {
         public verifyErrorExistsBetweenMarkers(startMarkerName: string, endMarkerName: string, negative: boolean) {
             const startMarker = this.getMarkerByName(startMarkerName);
             const endMarker = this.getMarkerByName(endMarkerName);
-            const predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
+            const predicate = function(errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
                 return ((errorMinChar === startPos) && (errorLimChar === endPos)) ? true : false;
             };
 
@@ -428,12 +429,12 @@ namespace FourSlash {
             let predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) => boolean;
 
             if (after) {
-                predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
+                predicate = function(errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
                     return ((errorMinChar >= startPos) && (errorLimChar >= startPos)) ? true : false;
                 };
             }
             else {
-                predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
+                predicate = function(errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {
                     return ((errorMinChar <= startPos) && (errorLimChar <= startPos)) ? true : false;
                 };
             }
@@ -458,7 +459,7 @@ namespace FourSlash {
                 endPos = endMarker.position;
             }
 
-            errors.forEach(function (error: ts.Diagnostic) {
+            errors.forEach(function(error: ts.Diagnostic) {
                 if (predicate(error.start, error.start + error.length, startPos, endPos)) {
                     exists = true;
                 }
@@ -475,7 +476,7 @@ namespace FourSlash {
                 Harness.IO.log("Unexpected error(s) found.  Error list is:");
             }
 
-            errors.forEach(function (error: ts.Diagnostic) {
+            errors.forEach(function(error: ts.Diagnostic) {
                 Harness.IO.log("  minChar: " + error.start +
                     ", limChar: " + (error.start + error.length) +
                     ", message: " + ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine()) + "\n");
@@ -593,9 +594,9 @@ namespace FourSlash {
 
         public noItemsWithSameNameButDifferentKind(): void {
             const completions = this.getCompletionListAtCaret();
-            const uniqueItems: ts.Map<string> = {};
+            const uniqueItems = ts.createMap<string>();
             for (const item of completions.entries) {
-                if (!ts.hasProperty(uniqueItems, item.name)) {
+                if (!(item.name in uniqueItems)) {
                     uniqueItems[item.name] = item.kind;
                 }
                 else {
@@ -773,7 +774,7 @@ namespace FourSlash {
         }
 
         public verifyRangesWithSameTextReferenceEachOther() {
-            ts.forEachValue(this.rangesByText(), ranges => this.verifyRangesReferenceEachOther(ranges));
+            ts.forEachProperty(this.rangesByText(), ranges => this.verifyRangesReferenceEachOther(ranges));
         }
 
         private verifyReferencesWorker(references: ts.ReferenceEntry[], fileName: string, start: number, end: number, isWriteAccess?: boolean, isDefinition?: boolean) {
@@ -1131,12 +1132,10 @@ namespace FourSlash {
 
             }
             Harness.Baseline.runBaseline(
-                "Breakpoint Locations for " + this.activeFile.fileName,
                 baselineFile,
                 () => {
                     return this.baselineCurrentFileLocations(pos => this.getBreakpointStatementLocation(pos));
-                },
-                true /* run immediately */);
+                });
         }
 
         public baselineGetEmitOutput() {
@@ -1158,7 +1157,6 @@ namespace FourSlash {
             }
 
             Harness.Baseline.runBaseline(
-                "Generate getEmitOutput baseline : " + emitFiles.join(" "),
                 this.testData.globalOptions[metadataOptionNames.baselineFile],
                 () => {
                     let resultString = "";
@@ -1184,8 +1182,7 @@ namespace FourSlash {
                     });
 
                     return resultString;
-                },
-                true /* run immediately */);
+                });
         }
 
         public printBreakpointLocation(pos: number) {
@@ -1348,14 +1345,7 @@ namespace FourSlash {
         }
 
         // Enters lines of text at the current caret position
-        public type(text: string) {
-            return this.typeHighFidelity(text);
-        }
-
-        // Enters lines of text at the current caret position, invoking
-        // language service APIs to mimic Visual Studio's behavior
-        // as much as possible
-        private typeHighFidelity(text: string) {
+        public type(text: string, highFidelity = false) {
             let offset = this.currentCaretPosition;
             const prevChar = " ";
             const checkCadence = (text.length >> 2) + 1;
@@ -1364,24 +1354,26 @@ namespace FourSlash {
                 // Make the edit
                 const ch = text.charAt(i);
                 this.languageServiceAdapterHost.editScript(this.activeFile.fileName, offset, offset, ch);
-                this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, offset);
+                if (highFidelity) {
+                    this.languageService.getBraceMatchingAtPosition(this.activeFile.fileName, offset);
+                }
 
                 this.updateMarkersForEdit(this.activeFile.fileName, offset, offset, ch);
                 offset++;
 
-                if (ch === "(" || ch === ",") {
-                    /* Signature help*/
-                    this.languageService.getSignatureHelpItems(this.activeFile.fileName, offset);
-                }
-                else if (prevChar === " " && /A-Za-z_/.test(ch)) {
-                    /* Completions */
-                    this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset);
-                }
+                if (highFidelity) {
+                    if (ch === "(" || ch === ",") {
+                        /* Signature help*/
+                        this.languageService.getSignatureHelpItems(this.activeFile.fileName, offset);
+                    }
+                    else if (prevChar === " " && /A-Za-z_/.test(ch)) {
+                        /* Completions */
+                        this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset);
+                    }
 
-                if (i % checkCadence === 0) {
-                    this.checkPostEditInvariants();
-                    // this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
-                    // this.languageService.getSemanticDiagnostics(this.activeFile.fileName);
+                    if (i % checkCadence === 0) {
+                        this.checkPostEditInvariants();
+                    }
                 }
 
                 // Handle post-keystroke formatting
@@ -1389,14 +1381,12 @@ namespace FourSlash {
                     const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
                         offset += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
-                        // this.checkPostEditInvariants();
                     }
                 }
             }
 
             // Move the caret to wherever we ended up
             this.currentCaretPosition = offset;
-
             this.fixCaretPosition();
             this.checkPostEditInvariants();
         }
@@ -1415,7 +1405,6 @@ namespace FourSlash {
                 const edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, offset, this.formatCodeOptions);
                 if (edits.length) {
                     offset += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
-                    this.checkPostEditInvariants();
                 }
             }
 
@@ -1639,10 +1628,11 @@ namespace FourSlash {
         }
 
         public rangesByText(): ts.Map<Range[]> {
-            const result: ts.Map<Range[]> = {};
+            const result = ts.createMap<Range[]>();
             for (const range of this.getRanges()) {
                 const text = this.rangeText(range);
-                (ts.getProperty(result, text) || (result[text] = [])).push(range);
+                const ranges = result[text] || (result[text] = []);
+                ranges.push(range);
             }
             return result;
         }
@@ -1736,13 +1726,11 @@ namespace FourSlash {
 
         public baselineCurrentFileNameOrDottedNameSpans() {
             Harness.Baseline.runBaseline(
-                "Name OrDottedNameSpans for " + this.activeFile.fileName,
                 this.testData.globalOptions[metadataOptionNames.baselineFile],
                 () => {
                     return this.baselineCurrentFileLocations(pos =>
                         this.getNameOrDottedNameSpan(pos));
-                },
-                true /* run immediately */);
+                });
         }
 
         public printNameOrDottedNameSpans(pos: number) {
@@ -1897,7 +1885,7 @@ namespace FourSlash {
 
         public verifyBraceCompletionAtPosition(negative: boolean, openingBrace: string) {
 
-            const openBraceMap: ts.Map<ts.CharacterCodes> = {
+            const openBraceMap = ts.createMap<ts.CharacterCodes>({
                 "(": ts.CharacterCodes.openParen,
                 "{": ts.CharacterCodes.openBrace,
                 "[": ts.CharacterCodes.openBracket,
@@ -1905,7 +1893,7 @@ namespace FourSlash {
                 '"': ts.CharacterCodes.doubleQuote,
                 "`": ts.CharacterCodes.backtick,
                 "<": ts.CharacterCodes.lessThan
-            };
+            });
 
             const charCode = openBraceMap[openingBrace];
 
@@ -2269,40 +2257,12 @@ namespace FourSlash {
     export function runFourSlashTestContent(basePath: string, testType: FourSlashTestType, content: string, fileName: string): void {
         // Parse out the files and their metadata
         const testData = parseTestData(basePath, content, fileName);
-
         const state = new TestState(basePath, testType, testData);
-
-        let result = "";
-        const fourslashFile: Harness.Compiler.TestFile = {
-            unitName: Harness.Compiler.fourslashFileName,
-            content: undefined,
-        };
-        const testFile: Harness.Compiler.TestFile = {
-            unitName: fileName,
-            content: content
-        };
-
-        const host = Harness.Compiler.createCompilerHost(
-            [fourslashFile, testFile],
-            (fn, contents) => result = contents,
-            ts.ScriptTarget.Latest,
-            Harness.IO.useCaseSensitiveFileNames(),
-            Harness.IO.getCurrentDirectory());
-
-        const program = ts.createProgram([Harness.Compiler.fourslashFileName, fileName], { outFile: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);
-
-        const sourceFile = host.getSourceFile(fileName, ts.ScriptTarget.ES3);
-
-        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"));
+        const output = ts.transpileModule(content, { reportDiagnostics: true });
+        if (output.diagnostics.length > 0) {
+            throw new Error(`Syntax error in ${basePath}: ${output.diagnostics[0].messageText}`);
         }
-
-        program.emit(sourceFile);
-
-        ts.Debug.assert(!!result);
-        runCode(result, state);
+        runCode(output.outputText, state);
     }
 
     function runCode(code: string, state: TestState): void {
@@ -2395,13 +2355,14 @@ ${code}
                 // Comment line, check for global/file @options and record them
                 const match = optionRegex.exec(line.substr(2));
                 if (match) {
-                    const fileMetadataNamesIndex = fileMetadataNames.indexOf(match[1]);
+                    const [key, value] = match.slice(1);
+                    const fileMetadataNamesIndex = fileMetadataNames.indexOf(key);
                     if (fileMetadataNamesIndex === -1) {
                         // Check if the match is already existed in the global options
-                        if (globalOptions[match[1]] !== undefined) {
-                            throw new Error("Global Option : '" + match[1] + "' is already existed");
+                        if (globalOptions[key] !== undefined) {
+                            throw new Error(`Global option '${key}' already exists`);
                         }
-                        globalOptions[match[1]] = match[2];
+                        globalOptions[key] = value;
                     }
                     else {
                         if (fileMetadataNamesIndex === fileMetadataNames.indexOf(metadataOptionNames.fileName)) {
@@ -2416,12 +2377,12 @@ ${code}
                                 resetLocalData();
                             }
 
-                            currentFileName = basePath + "/" + match[2];
-                            currentFileOptions[match[1]] = match[2];
+                            currentFileName = basePath + "/" + value;
+                            currentFileOptions[key] = value;
                         }
                         else {
                             // Add other fileMetadata flag
-                            currentFileOptions[match[1]] = match[2];
+                            currentFileOptions[key] = value;
                         }
                     }
                 }
@@ -2509,7 +2470,7 @@ ${code}
         }
 
         const marker: Marker = {
-            fileName: fileName,
+            fileName,
             position: location.position,
             data: markerValue
         };
@@ -2526,7 +2487,7 @@ ${code}
 
     function recordMarker(fileName: string, location: LocationInformation, name: string, markerMap: MarkerMap, markers: Marker[]): Marker {
         const marker: Marker = {
-            fileName: fileName,
+            fileName,
             position: location.position
         };
 
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index c38be7b07d644..fb0634676982d 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -822,7 +822,7 @@ namespace Harness {
 
             export function readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[]) {
                 const fs = new Utils.VirtualFileSystem(path, useCaseSensitiveFileNames());
-                for (const file in listFiles(path)) {
+                for (const file of listFiles(path)) {
                     fs.addFile(file);
                 }
                 return ts.matchFiles(path, extension, exclude, include, useCaseSensitiveFileNames(), getCurrentDirectory(), path => {
@@ -922,9 +922,9 @@ namespace Harness {
         export const defaultLibFileName = "lib.d.ts";
         export const es2015DefaultLibFileName = "lib.es2015.d.ts";
 
-        const libFileNameSourceFileMap: ts.Map<ts.SourceFile> = {
+        const libFileNameSourceFileMap=  ts.createMap<ts.SourceFile>({
             [defaultLibFileName]: createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts"), /*languageVersion*/ ts.ScriptTarget.Latest)
-        };
+        });
 
         export function getDefaultLibrarySourceFile(fileName = defaultLibFileName): ts.SourceFile {
             if (!isDefaultLibraryFile(fileName)) {
@@ -1079,13 +1079,13 @@ namespace Harness {
         let optionsIndex: ts.Map<ts.CommandLineOption>;
         function getCommandLineOption(name: string): ts.CommandLineOption {
             if (!optionsIndex) {
-                optionsIndex = {};
+                optionsIndex = ts.createMap<ts.CommandLineOption>();
                 const optionDeclarations = harnessOptionDeclarations.concat(ts.optionDeclarations);
                 for (const option of optionDeclarations) {
                     optionsIndex[option.name.toLowerCase()] = option;
                 }
             }
-            return ts.lookUp(optionsIndex, name.toLowerCase());
+            return optionsIndex[name.toLowerCase()];
         }
 
         export function setCompilerOptionsFromHarnessSetting(settings: Harness.TestCaseParser.CompilerSettings, options: ts.CompilerOptions & HarnessOptions): void {
@@ -1402,6 +1402,220 @@ namespace Harness {
                 Harness.IO.newLine() + Harness.IO.newLine() + outputLines.join("\r\n");
         }
 
+        export function doErrorBaseline(baselinePath: string, inputFiles: TestFile[], errors: ts.Diagnostic[]) {
+            Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?$/, ".errors.txt"), (): string => {
+                if (errors.length === 0) {
+                    /* tslint:disable:no-null-keyword */
+                    return null;
+                    /* tslint:enable:no-null-keyword */
+                }
+                return getErrorBaseline(inputFiles, errors);
+            });
+        }
+
+        export function doTypeAndSymbolBaseline(baselinePath: string, result: CompilerResult, allFiles: {unitName: string, content: string}[], opts?: Harness.Baseline.BaselineOptions) {
+            if (result.errors.length !== 0) {
+                return;
+            }
+            // The full walker simulates the types that you would get from doing a full
+            // compile.  The pull walker simulates the types you get when you just do
+            // a type query for a random node (like how the LS would do it).  Most of the
+            // time, these will be the same.  However, occasionally, they can be different.
+            // Specifically, when the compiler internally depends on symbol IDs to order
+            // things, then we may see different results because symbols can be created in a
+            // different order with 'pull' operations, and thus can produce slightly differing
+            // output.
+            //
+            // For example, with a full type check, we may see a type displayed as: number | string
+            // But with a pull type check, we may see it as:                        string | number
+            //
+            // These types are equivalent, but depend on what order the compiler observed
+            // certain parts of the program.
+
+            const program = result.program;
+
+            const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true);
+
+            const fullResults = ts.createMap<TypeWriterResult[]>();
+
+            for (const sourceFile of allFiles) {
+                fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
+            }
+
+            // Produce baselines.  The first gives the types for all expressions.
+            // The second gives symbols for all identifiers.
+            let e1: Error, e2: Error;
+            try {
+                checkBaseLines(/*isSymbolBaseLine*/ false);
+            }
+            catch (e) {
+                e1 = e;
+            }
+
+            try {
+                checkBaseLines(/*isSymbolBaseLine*/ true);
+            }
+            catch (e) {
+                e2 = e;
+            }
+
+            if (e1 || e2) {
+                throw e1 || e2;
+            }
+
+            return;
+
+            function checkBaseLines(isSymbolBaseLine: boolean) {
+                const fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
+
+                const fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
+
+                Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?/, fullExtension), () => fullBaseLine, opts);
+            }
+
+            function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
+                const typeLines: string[] = [];
+                const typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
+
+                allFiles.forEach(file => {
+                    const codeLines = file.content.split("\n");
+                    typeWriterResults[file.unitName].forEach(result => {
+                        if (isSymbolBaseline && !result.symbol) {
+                            return;
+                        }
+
+                        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];
+                        const existingTypeInfo = typeMap[file.unitName][result.line];
+                        if (existingTypeInfo) {
+                            typeInfo = existingTypeInfo.concat(typeInfo);
+                        }
+                        typeMap[file.unitName][result.line] = typeInfo;
+                    });
+
+                    typeLines.push("=== " + file.unitName + " ===\r\n");
+                    for (let i = 0; i < codeLines.length; i++) {
+                        const currentCodeLine = codeLines[i];
+                        typeLines.push(currentCodeLine + "\r\n");
+                        if (typeMap[file.unitName]) {
+                            const typeInfo = typeMap[file.unitName][i];
+                            if (typeInfo) {
+                                typeInfo.forEach(ty => {
+                                    typeLines.push(">" + ty + "\r\n");
+                                });
+                                if (i + 1 < codeLines.length && (codeLines[i + 1].match(/^\s*[{|}]\s*$/) || codeLines[i + 1].trim() === "")) {
+                                }
+                                else {
+                                    typeLines.push("\r\n");
+                                }
+                            }
+                        }
+                        else {
+                            typeLines.push("No type information for this code.");
+                        }
+                    }
+                });
+
+                return typeLines.join("");
+            }
+        }
+
+        function getByteOrderMarkText(file: Harness.Compiler.GeneratedFile): string {
+            return file.writeByteOrderMark ? "\u00EF\u00BB\u00BF" : "";
+        }
+
+        export function doSourcemapBaseline(baselinePath: string, options: ts.CompilerOptions, result: CompilerResult) {
+            if (options.inlineSourceMap) {
+                if (result.sourceMaps.length > 0) {
+                    throw new Error("No sourcemap files should be generated if inlineSourceMaps was set.");
+                }
+                return;
+            }
+            else if (options.sourceMap) {
+                if (result.sourceMaps.length !== result.files.length) {
+                    throw new Error("Number of sourcemap files should be same as js files.");
+                }
+
+                Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?/, ".js.map"), () => {
+                    if ((options.noEmitOnError && result.errors.length !== 0) || result.sourceMaps.length === 0) {
+                        // We need to return null here or the runBaseLine will actually create a empty file.
+                        // Baselining isn't required here because there is no output.
+                        /* tslint:disable:no-null-keyword */
+                        return null;
+                        /* tslint:enable:no-null-keyword */
+                    }
+
+                    let sourceMapCode = "";
+                    for (let i = 0; i < result.sourceMaps.length; i++) {
+                        sourceMapCode += "//// [" + Harness.Path.getFileName(result.sourceMaps[i].fileName) + "]\r\n";
+                        sourceMapCode += getByteOrderMarkText(result.sourceMaps[i]);
+                        sourceMapCode += result.sourceMaps[i].code;
+                    }
+
+                    return sourceMapCode;
+                });
+            }
+        }
+
+        export function doJsEmitBaseline(baselinePath: string, header: string, options: ts.CompilerOptions, result: CompilerResult, toBeCompiled: Harness.Compiler.TestFile[], otherFiles: Harness.Compiler.TestFile[], harnessSettings: Harness.TestCaseParser.CompilerSettings) {
+            if (!options.noEmit && result.files.length === 0 && result.errors.length === 0) {
+                throw new Error("Expected at least one js file to be emitted or at least one error to be created.");
+            }
+
+            // check js output
+            Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?/, ".js"), () => {
+                let tsCode = "";
+                const tsSources = otherFiles.concat(toBeCompiled);
+                if (tsSources.length > 1) {
+                    tsCode += "//// [" + header + "] ////\r\n\r\n";
+                }
+                for (let i = 0; i < tsSources.length; i++) {
+                    tsCode += "//// [" + Harness.Path.getFileName(tsSources[i].unitName) + "]\r\n";
+                    tsCode += tsSources[i].content + (i < (tsSources.length - 1) ? "\r\n" : "");
+                }
+
+                let jsCode = "";
+                for (let i = 0; i < result.files.length; i++) {
+                    jsCode += "//// [" + Harness.Path.getFileName(result.files[i].fileName) + "]\r\n";
+                    jsCode += getByteOrderMarkText(result.files[i]);
+                    jsCode += result.files[i].code;
+                }
+
+                if (result.declFilesCode.length > 0) {
+                    jsCode += "\r\n\r\n";
+                    for (let i = 0; i < result.declFilesCode.length; i++) {
+                        jsCode += "//// [" + Harness.Path.getFileName(result.declFilesCode[i].fileName) + "]\r\n";
+                        jsCode += getByteOrderMarkText(result.declFilesCode[i]);
+                        jsCode += result.declFilesCode[i].code;
+                    }
+                }
+
+                const declFileCompilationResult =
+                    Harness.Compiler.compileDeclarationFiles(
+                        toBeCompiled, otherFiles, result, harnessSettings, options, /*currentDirectory*/ undefined);
+
+                if (declFileCompilationResult && declFileCompilationResult.declResult.errors.length) {
+                    jsCode += "\r\n\r\n//// [DtsFileErrors]\r\n";
+                    jsCode += "\r\n\r\n";
+                    jsCode += Harness.Compiler.getErrorBaseline(declFileCompilationResult.declInputFiles.concat(declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.errors);
+                }
+
+                if (jsCode.length > 0) {
+                    return tsCode + "\r\n\r\n" + jsCode;
+                }
+                else {
+                    /* tslint:disable:no-null-keyword */
+                    return null;
+                    /* tslint:enable:no-null-keyword */
+                }
+            });
+        }
+
         export function collateOutputs(outputFiles: Harness.Compiler.GeneratedFile[]): string {
             // Collect, test, and sort the fileNames
             outputFiles.sort((a, b) => cleanName(a.fileName).localeCompare(cleanName(b.fileName)));
@@ -1643,6 +1857,7 @@ namespace Harness {
 
     /** Support class for baseline files */
     export namespace Baseline {
+        const NoContent = "<no content>";
 
         export interface BaselineOptions {
             Subfolder?: string;
@@ -1677,31 +1892,7 @@ namespace Harness {
         }
 
         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
-            // Creates the directory including its parent if not already present
-            function createDirectoryStructure(dirName: string) {
-                if (fileCache[dirName] || IO.directoryExists(dirName)) {
-                    fileCache[dirName] = true;
-                    return;
-                }
-
-                const parentDirectory = IO.directoryName(dirName);
-                if (parentDirectory != "") {
-                    createDirectoryStructure(parentDirectory);
-                }
-                IO.createDirectory(dirName);
-                fileCache[dirName] = true;
-            }
-
-            // Create folders if needed
-            createDirectoryStructure(Harness.IO.directoryName(actualFileName));
-
-            // Delete the actual file in case it fails
-            if (IO.fileExists(actualFileName)) {
-                IO.deleteFile(actualFileName);
-            }
+        function generateActual(generateContent: () => string): string {
 
             const actual = generateContent();
 
@@ -1709,14 +1900,6 @@ namespace Harness {
                 throw new Error("The generated content was \"undefined\". Return \"null\" if no baselining is required.\"");
             }
 
-            // Store the content in the 'local' folder so we
-            // can accept it later (manually)
-            /* tslint:disable:no-null-keyword */
-            if (actual !== null) {
-            /* tslint:enable:no-null-keyword */
-                IO.writeFile(actualFileName, actual);
-            }
-
             return actual;
         }
 
@@ -1733,7 +1916,7 @@ namespace Harness {
             /* tslint:disable:no-null-keyword */
             if (actual === null) {
             /* tslint:enable:no-null-keyword */
-                actual = "<no content>";
+                actual = NoContent;
             }
 
             let expected = "<no content>";
@@ -1744,40 +1927,50 @@ namespace Harness {
             return { expected, actual };
         }
 
-        function writeComparison(expected: string, actual: string, relativeFileName: string, actualFileName: string, descriptionForDescribe: string) {
-            const encoded_actual = Utils.encodeString(actual);
-            if (expected != encoded_actual) {
-                // Overwrite & issue error
-                const errMsg = "The baseline file " + relativeFileName + " has changed.";
-                throw new Error(errMsg);
+        function writeComparison(expected: string, actual: string, relativeFileName: string, actualFileName: 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
+            // Creates the directory including its parent if not already present
+            function createDirectoryStructure(dirName: string) {
+                if (fileCache[dirName] || IO.directoryExists(dirName)) {
+                    fileCache[dirName] = true;
+                    return;
+                }
+
+                const parentDirectory = IO.directoryName(dirName);
+                if (parentDirectory != "") {
+                    createDirectoryStructure(parentDirectory);
+                }
+                IO.createDirectory(dirName);
+                fileCache[dirName] = true;
             }
-        }
 
-        export function runBaseline(
-            descriptionForDescribe: string,
-            relativeFileName: string,
-            generateContent: () => string,
-            runImmediately = false,
-            opts?: BaselineOptions): void {
+            // Create folders if needed
+            createDirectoryStructure(Harness.IO.directoryName(actualFileName));
 
-            let actual = <string>undefined;
-            const actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
-            try {
-                if (runImmediately) {
-                    actual = generateActual(actualFileName, generateContent);
-                    const comparison = compareToBaseline(actual, relativeFileName, opts);
-                    writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName, descriptionForDescribe);
+            // Delete the actual file in case it fails
+            if (IO.fileExists(actualFileName)) {
+                IO.deleteFile(actualFileName);
+            }
+
+            const encoded_actual = Utils.encodeString(actual);
+            if (expected !== encoded_actual) {
+                if (actual === NoContent) {
+                    IO.writeFile(actualFileName + ".delete", "");
                 }
                 else {
-                    actual = generateActual(actualFileName, generateContent);
-
-                    const comparison = compareToBaseline(actual, relativeFileName, opts);
-                    writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName, descriptionForDescribe);
+                    IO.writeFile(actualFileName, actual);
                 }
+                throw new Error(`The baseline file ${relativeFileName} has changed.`);
             }
-            catch (e) {
-                throw Utils.filterStack(e);
-            }
+        }
+
+        export function runBaseline(relativeFileName: string, generateContent: () => string, opts?: BaselineOptions): void {
+            const actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
+
+            const actual = generateActual(generateContent);
+            const comparison = compareToBaseline(actual, relativeFileName, opts);
+            writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName);
         }
     }
 
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index e17230aacf29f..9421cbb3c895d 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -123,7 +123,7 @@ namespace Harness.LanguageService {
     }
 
     export class LanguageServiceAdapterHost {
-        protected fileNameToScript: ts.Map<ScriptInfo> = {};
+        protected fileNameToScript = ts.createMap<ScriptInfo>();
 
         constructor(protected cancellationToken = DefaultHostCancellationToken.Instance,
                     protected settings = ts.getDefaultCompilerOptions()) {
@@ -135,7 +135,7 @@ namespace Harness.LanguageService {
 
         public getFilenames(): string[] {
             const fileNames: string[] = [];
-            ts.forEachValue(this.fileNameToScript, (scriptInfo) => {
+            ts.forEachProperty(this.fileNameToScript, (scriptInfo) => {
                 if (scriptInfo.isRootFile) {
                     // only include root files here
                     // usually it means that we won't include lib.d.ts in the list of root files so it won't mess the computation of compilation root dir.
@@ -146,7 +146,7 @@ namespace Harness.LanguageService {
         }
 
         public getScriptInfo(fileName: string): ScriptInfo {
-            return ts.lookUp(this.fileNameToScript, fileName);
+            return this.fileNameToScript[fileName];
         }
 
         public addScript(fileName: string, content: string, isRootFile: boolean): void {
@@ -235,7 +235,7 @@ namespace Harness.LanguageService {
                 this.getModuleResolutionsForFile = (fileName) => {
                     const scriptInfo = this.getScriptInfo(fileName);
                     const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
-                    const imports: ts.Map<string> = {};
+                    const imports = ts.createMap<string>();
                     for (const module of preprocessInfo.importedFiles) {
                         const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
                         if (resolutionInfo.resolvedModule) {
@@ -248,7 +248,7 @@ namespace Harness.LanguageService {
                     const scriptInfo = this.getScriptInfo(fileName);
                     if (scriptInfo) {
                         const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
-                        const resolutions: ts.Map<ts.ResolvedTypeReferenceDirective> = {};
+                        const resolutions = ts.createMap<ts.ResolvedTypeReferenceDirective>();
                         const settings = this.nativeHost.getCompilationSettings();
                         for (const typeReferenceDirective of preprocessInfo.typeReferenceDirectives) {
                             const resolutionInfo = ts.resolveTypeReferenceDirective(typeReferenceDirective.fileName, fileName, settings, moduleResolutionHost);
diff --git a/src/harness/projectsRunner.ts b/src/harness/projectsRunner.ts
index d522940b740ca..6b10295122efc 100644
--- a/src/harness/projectsRunner.ts
+++ b/src/harness/projectsRunner.ts
@@ -253,18 +253,15 @@ class ProjectRunner extends RunnerBase {
                     moduleResolution: ts.ModuleResolutionKind.Classic, // currently all tests use classic module resolution kind, this will change in the future
                 };
                 // Set the values specified using json
-                const optionNameMap: ts.Map<ts.CommandLineOption> = {};
-                ts.forEach(ts.optionDeclarations, option => {
-                    optionNameMap[option.name] = option;
-                });
+                const optionNameMap = ts.arrayToMap(ts.optionDeclarations, option => option.name);
                 for (const name in testCase) {
-                    if (name !== "mapRoot" && name !== "sourceRoot" && ts.hasProperty(optionNameMap, name)) {
+                    if (name !== "mapRoot" && name !== "sourceRoot" && name in optionNameMap) {
                         const option = optionNameMap[name];
                         const optType = option.type;
                         let value = <any>testCase[name];
                         if (typeof optType !== "string") {
                             const key = value.toLowerCase();
-                            if (ts.hasProperty(optType, key)) {
+                            if (key in optType) {
                                 value = optType[key];
                             }
                         }
@@ -462,7 +459,7 @@ class ProjectRunner extends RunnerBase {
                     });
 
                     it("Resolution information of (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
-                        Harness.Baseline.runBaseline("Resolution information of (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".json", () => {
+                        Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".json", () => {
                             return JSON.stringify(getCompilerResolutionInfo(), undefined, "    ");
                         });
                     });
@@ -470,7 +467,7 @@ class ProjectRunner extends RunnerBase {
 
                     it("Errors for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                         if (compilerResult.errors.length) {
-                            Harness.Baseline.runBaseline("Errors for (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".errors.txt", () => {
+                            Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".errors.txt", () => {
                                 return getErrorsBaseline(compilerResult);
                             });
                         }
@@ -483,7 +480,7 @@ class ProjectRunner extends RunnerBase {
                                 // There may be multiple files with different baselines. Run all and report at the end, else
                                 // it stops copying the remaining emitted files from 'local/projectOutput' to 'local/project'.
                                 try {
-                                    Harness.Baseline.runBaseline("Baseline of emitted result (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + outputFile.fileName, () => {
+                                    Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + outputFile.fileName, () => {
                                         try {
                                             return Harness.IO.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind));
                                         }
@@ -502,10 +499,9 @@ class ProjectRunner extends RunnerBase {
                         }
                     });
 
-
                     // it("SourceMapRecord for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                     //     if (compilerResult.sourceMapData) {
-                    //         Harness.Baseline.runBaseline("SourceMapRecord for (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".sourcemap.txt", () => {
+                    //         Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".sourcemap.txt", () => {
                     //             return Harness.SourceMapRecorder.getSourceMapRecord(compilerResult.sourceMapData, compilerResult.program,
                     //                 ts.filter(compilerResult.outputFiles, outputFile => Harness.Compiler.isJS(outputFile.emittedFileName)));
                     //         });
@@ -518,7 +514,7 @@ class ProjectRunner extends RunnerBase {
                         if (!compilerResult.errors.length && testCase.declaration) {
                             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", () => {
+                                Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".dts.errors.txt", () => {
                                     return getErrorsBaseline(dTsCompileResult);
                                 });
                             }
diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts
index 1266ffa5d3783..ba1ab71ec19d3 100644
--- a/src/harness/rwcRunner.ts
+++ b/src/harness/rwcRunner.ts
@@ -158,55 +158,56 @@ namespace RWC {
 
 
             it("has the expected emitted code", () => {
-                Harness.Baseline.runBaseline("has the expected emitted code", baseName + ".output.js", () => {
+                Harness.Baseline.runBaseline(`${baseName}.output.js`, () => {
                     return Harness.Compiler.collateOutputs(compilerResult.files);
-                }, false, baselineOpts);
+                }, baselineOpts);
             });
 
             it("has the expected declaration file content", () => {
-                Harness.Baseline.runBaseline("has the expected declaration file content", baseName + ".d.ts", () => {
+                Harness.Baseline.runBaseline(`${baseName}.d.ts`, () => {
                     if (!compilerResult.declFilesCode.length) {
                         return null;
                     }
 
                     return Harness.Compiler.collateOutputs(compilerResult.declFilesCode);
-                }, false, baselineOpts);
+                }, baselineOpts);
             });
 
             it("has the expected source maps", () => {
-                Harness.Baseline.runBaseline("has the expected source maps", baseName + ".map", () => {
+                Harness.Baseline.runBaseline(`${baseName}.map`, () => {
                     if (!compilerResult.sourceMaps.length) {
                         return null;
                     }
 
                     return Harness.Compiler.collateOutputs(compilerResult.sourceMaps);
-                }, false, baselineOpts);
+                }, baselineOpts);
             });
 
             /*it("has correct source map record", () => {
                 if (compilerOptions.sourceMap) {
-                    Harness.Baseline.runBaseline("has correct source map record", baseName + ".sourcemap.txt", () => {
+                    Harness.Baseline.runBaseline(baseName + ".sourcemap.txt", () => {
                         return compilerResult.getSourceMapRecord();
-                    }, false, baselineOpts);
+                    }, baselineOpts);
                 }
             });*/
 
             it("has the expected errors", () => {
-                Harness.Baseline.runBaseline("has the expected errors", baseName + ".errors.txt", () => {
+                Harness.Baseline.runBaseline(`${baseName}.errors.txt`, () => {
                     if (compilerResult.errors.length === 0) {
                         return null;
                     }
                     // Do not include the library in the baselines to avoid noise
                     const baselineFiles = inputFiles.concat(otherFiles).filter(f => !Harness.isDefaultLibraryFile(f.unitName));
-                    return Harness.Compiler.getErrorBaseline(baselineFiles, compilerResult.errors);
-                }, false, baselineOpts);
+                    const errors = compilerResult.errors.filter(e => !Harness.isDefaultLibraryFile(e.file.fileName));
+                    return Harness.Compiler.getErrorBaseline(baselineFiles, errors);
+                }, baselineOpts);
             });
 
             // Ideally, a generated declaration file will have no errors. But we allow generated
             // declaration file errors as part of the baseline.
             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", () => {
+                    Harness.Baseline.runBaseline(`${baseName}.dts.errors.txt`, () => {
                         const declFileCompilationResult = Harness.Compiler.compileDeclarationFiles(
                             inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
 
@@ -217,11 +218,16 @@ namespace RWC {
                         return Harness.Compiler.minimalDiagnosticsToString(declFileCompilationResult.declResult.errors) +
                             Harness.IO.newLine() + Harness.IO.newLine() +
                             Harness.Compiler.getErrorBaseline(declFileCompilationResult.declInputFiles.concat(declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.errors);
-                    }, false, baselineOpts);
+                    }, baselineOpts);
                 }
             });
 
-            // TODO: Type baselines (need to refactor out from compilerRunner)
+            it("has the expected types", () => {
+                Harness.Compiler.doTypeAndSymbolBaseline(`${baseName}.types`, compilerResult, inputFiles
+                    .concat(otherFiles)
+                    .filter(file => !!compilerResult.program.getSourceFile(file.unitName))
+                    .filter(e => !Harness.isDefaultLibraryFile(e.unitName)), baselineOpts);
+            });
         });
     }
 }
diff --git a/src/harness/test262Runner.ts b/src/harness/test262Runner.ts
index c44b2286b832d..66cf474824b14 100644
--- a/src/harness/test262Runner.ts
+++ b/src/harness/test262Runner.ts
@@ -67,21 +67,21 @@ class Test262BaselineRunner extends RunnerBase {
             });
 
             it("has the expected emitted code", () => {
-                Harness.Baseline.runBaseline("has the expected emitted code", testState.filename + ".output.js", () => {
+                Harness.Baseline.runBaseline(testState.filename + ".output.js", () => {
                     const files = testState.compilerResult.files.filter(f => f.fileName !== Test262BaselineRunner.helpersFilePath);
                     return Harness.Compiler.collateOutputs(files);
-                }, false, Test262BaselineRunner.baselineOptions);
+                }, Test262BaselineRunner.baselineOptions);
             });
 
             it("has the expected errors", () => {
-                Harness.Baseline.runBaseline("has the expected errors", testState.filename + ".errors.txt", () => {
+                Harness.Baseline.runBaseline(testState.filename + ".errors.txt", () => {
                     const errors = testState.compilerResult.errors;
                     if (errors.length === 0) {
                         return null;
                     }
 
                     return Harness.Compiler.getErrorBaseline(testState.inputFiles, errors);
-                }, false, Test262BaselineRunner.baselineOptions);
+                }, Test262BaselineRunner.baselineOptions);
             });
 
             it("satisfies invariants", () => {
@@ -90,10 +90,10 @@ class Test262BaselineRunner extends RunnerBase {
             });
 
             it("has the expected AST", () => {
-                Harness.Baseline.runBaseline("has the expected AST", testState.filename + ".AST.txt", () => {
+                Harness.Baseline.runBaseline(testState.filename + ".AST.txt", () => {
                     const sourceFile = testState.compilerResult.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
                     return Utils.sourceFileToJSON(sourceFile);
-                }, false, Test262BaselineRunner.baselineOptions);
+                }, Test262BaselineRunner.baselineOptions);
             });
         });
     }
diff --git a/src/harness/tsconfig.json b/src/harness/tsconfig.json
index 3b9025c27c362..a21faf9dd0745 100644
--- a/src/harness/tsconfig.json
+++ b/src/harness/tsconfig.json
@@ -89,6 +89,7 @@
         "./unittests/convertCompilerOptionsFromJson.ts",
         "./unittests/convertTypingOptionsFromJson.ts",
         "./unittests/tsserverProjectSystem.ts",
-        "./unittests/matchFiles.ts"
+        "./unittests/matchFiles.ts",
+        "./unittests/initializeTSConfig.ts"
     ]
 }
diff --git a/src/harness/unittests/cachingInServerLSHost.ts b/src/harness/unittests/cachingInServerLSHost.ts
index ce2046ae6b6d9..0b8935b380eb6 100644
--- a/src/harness/unittests/cachingInServerLSHost.ts
+++ b/src/harness/unittests/cachingInServerLSHost.ts
@@ -7,16 +7,16 @@ namespace ts {
     }
 
     function createDefaultServerHost(fileMap: Map<File>): server.ServerHost {
-        const existingDirectories: Map<boolean> = {};
-        forEachValue(fileMap, v => {
-            let dir = getDirectoryPath(v.name);
+        const existingDirectories = createMap<boolean>();
+        for (const name in fileMap) {
+            let dir = getDirectoryPath(name);
             let previous: string;
             do {
                 existingDirectories[dir] = true;
                 previous = dir;
                 dir = getDirectoryPath(dir);
             } while (dir !== previous);
-        });
+        }
         return {
             args: <string[]>[],
             newLine: "\r\n",
@@ -24,7 +24,7 @@ namespace ts {
             write: (s: string) => {
             },
             readFile: (path: string, encoding?: string): string => {
-                return hasProperty(fileMap, path) && fileMap[path].content;
+                return path in fileMap ? fileMap[path].content : undefined;
             },
             writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => {
                 throw new Error("NYI");
@@ -33,10 +33,10 @@ namespace ts {
                 throw new Error("NYI");
             },
             fileExists: (path: string): boolean => {
-                return hasProperty(fileMap, path);
+                return path in fileMap;
             },
             directoryExists: (path: string): boolean => {
-                return hasProperty(existingDirectories, path);
+                return existingDirectories[path] || false;
             },
             createDirectory: (path: string) => {
             },
@@ -102,7 +102,7 @@ namespace ts {
                 content: `foo()`
             };
 
-            const serverHost = createDefaultServerHost({ [root.name]: root, [imported.name]: imported });
+            const serverHost = createDefaultServerHost(createMap({ [root.name]: root, [imported.name]: imported }));
             const { project, rootScriptInfo } = createProject(root.name, serverHost);
 
             // ensure that imported file was found
@@ -194,7 +194,7 @@ namespace ts {
                 content: `export var y = 1`
             };
 
-            const fileMap: Map<File> = { [root.name]: root };
+            const fileMap = createMap({ [root.name]: root });
             const serverHost = createDefaultServerHost(fileMap);
             const originalFileExists = serverHost.fileExists;
 
diff --git a/src/harness/unittests/initializeTSConfig.ts b/src/harness/unittests/initializeTSConfig.ts
new file mode 100644
index 0000000000000..cb995212a944a
--- /dev/null
+++ b/src/harness/unittests/initializeTSConfig.ts
@@ -0,0 +1,44 @@
+/// <reference path="..\harness.ts" />
+/// <reference path="..\..\compiler\commandLineParser.ts" />
+
+namespace ts {
+    describe("initTSConfig", () => {
+        function initTSConfigCorrectly(name: string, commandLinesArgs: string[]) {
+            describe(name, () => {
+                const commandLine = parseCommandLine(commandLinesArgs);
+                const initResult = generateTSConfig(commandLine.options, commandLine.fileNames);
+                const outputFileName = `tsConfig/${name.replace(/[^a-z0-9\-. ]/ig, "")}/tsconfig.json`;
+
+                it(`Correct output for ${outputFileName}`, () => {
+                    Harness.Baseline.runBaseline(outputFileName, () => {
+                        if (initResult) {
+                            return JSON.stringify(initResult, undefined, 4);
+                        }
+                        else {
+                            // This can happen if compiler recieve invalid compiler-options
+                            /* tslint:disable:no-null-keyword */
+                            return null;
+                            /* tslint:enable:no-null-keyword */
+                        }
+                    });
+                });
+            });
+        }
+
+        initTSConfigCorrectly("Default initialized TSConfig", ["--init"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with files options", ["--init", "file0.st", "file1.ts", "file2.ts"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with boolean value compiler options", ["--init", "--noUnusedLocals"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with enum value compiler options", ["--init", "--target", "es5", "--jsx", "react"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with list compiler options", ["--init", "--types", "jquery,mocha"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with list compiler options with enum value", ["--init", "--lib", "es5,es2015.core"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with incorrect compiler option", ["--init", "--someNonExistOption"]);
+
+        initTSConfigCorrectly("Initialized TSConfig with incorrect compiler option value", ["--init", "--lib", "nonExistLib,es5,es2015.promise"]);
+    });
+}
\ No newline at end of file
diff --git a/src/harness/unittests/jsDocParsing.ts b/src/harness/unittests/jsDocParsing.ts
index 936ea77a1dcd6..c8f6d60e4ad8d 100644
--- a/src/harness/unittests/jsDocParsing.ts
+++ b/src/harness/unittests/jsDocParsing.ts
@@ -9,7 +9,7 @@ namespace ts {
                     const typeAndDiagnostics = ts.parseJSDocTypeExpressionForTests(content);
                     assert.isTrue(typeAndDiagnostics && typeAndDiagnostics.diagnostics.length === 0);
 
-                    Harness.Baseline.runBaseline("parseCorrectly", "JSDocParsing/TypeExpressions.parsesCorrectly." + name + ".json",
+                    Harness.Baseline.runBaseline("JSDocParsing/TypeExpressions.parsesCorrectly." + name + ".json",
                         () => Utils.sourceFileToJSON(typeAndDiagnostics.jsDocTypeExpression.type));
                 });
             }
@@ -99,7 +99,7 @@ namespace ts {
                         Debug.fail("Comment has at least one diagnostic: " + comment.diagnostics[0].messageText);
                     }
 
-                    Harness.Baseline.runBaseline("parseCorrectly", "JSDocParsing/DocComments.parsesCorrectly." + name + ".json",
+                    Harness.Baseline.runBaseline("JSDocParsing/DocComments.parsesCorrectly." + name + ".json",
                         () => JSON.stringify(comment.jsDocComment,
                             (k, v) => v && v.pos !== undefined ? JSON.parse(Utils.sourceFileToJSON(v)) : v, 4));
                 });
diff --git a/src/harness/unittests/moduleResolution.ts b/src/harness/unittests/moduleResolution.ts
index 5f63889b08498..3e1ac171216e0 100644
--- a/src/harness/unittests/moduleResolution.ts
+++ b/src/harness/unittests/moduleResolution.ts
@@ -10,7 +10,7 @@ namespace ts {
         const map = arrayToMap(files, f => f.name);
 
         if (hasDirectoryExists) {
-            const directories: Map<string> = {};
+            const directories = createMap<string>();
             for (const f of files) {
                 let name = getDirectoryPath(f.name);
                 while (true) {
@@ -25,19 +25,19 @@ namespace ts {
             return {
                 readFile,
                 directoryExists: path => {
-                    return hasProperty(directories, path);
+                    return path in directories;
                 },
                 fileExists: path => {
-                    assert.isTrue(hasProperty(directories, getDirectoryPath(path)), `'fileExists' '${path}' request in non-existing directory`);
-                    return hasProperty(map, path);
+                    assert.isTrue(getDirectoryPath(path) in directories, `'fileExists' '${path}' request in non-existing directory`);
+                    return path in map;
                 }
             };
         }
         else {
-            return { readFile, fileExists: path => hasProperty(map, path), };
+            return { readFile, fileExists: path => path in map, };
         }
         function readFile(path: string): string {
-            return hasProperty(map, path) ? map[path].content : undefined;
+            return path in map ? map[path].content : undefined;
         }
     }
 
@@ -287,7 +287,7 @@ namespace ts {
             const host: CompilerHost = {
                 getSourceFile: (fileName: string, languageVersion: ScriptTarget) => {
                     const path = normalizePath(combinePaths(currentDirectory, fileName));
-                    return hasProperty(files, path) ? createSourceFile(fileName, files[path], languageVersion) : undefined;
+                    return path in files ? createSourceFile(fileName, files[path], languageVersion) : undefined;
                 },
                 getDefaultLibFileName: () => "lib.d.ts",
                 writeFile: (fileName, content): void => { throw new Error("NotImplemented"); },
@@ -298,7 +298,7 @@ namespace ts {
                 useCaseSensitiveFileNames: () => false,
                 fileExists: fileName => {
                     const path = normalizePath(combinePaths(currentDirectory, fileName));
-                    return hasProperty(files, path);
+                    return path in files;
                 },
                 readFile: (fileName): string => { throw new Error("NotImplemented"); }
             };
@@ -318,7 +318,7 @@ namespace ts {
         }
 
         it("should find all modules", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/b/c/first/shared.ts": `
 class A {}
 export = A`,
@@ -332,23 +332,23 @@ import Shared = require('../first/shared');
 class C {}
 export = C;
                 `
-            };
+            });
             test(files, "/a/b/c/first/second", ["class_a.ts"], 3, ["../../../c/third/class_c.ts"]);
         });
 
         it("should find modules in node_modules", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/parent/node_modules/mod/index.d.ts": "export var x",
                 "/parent/app/myapp.ts": `import {x} from "mod"`
-            };
+            });
             test(files, "/parent/app", ["myapp.ts"], 2, []);
         });
 
         it("should find file referenced via absolute and relative names", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/b/c.ts": `/// <reference path="b.ts"/>`,
                 "/a/b/b.ts": "var x"
-            };
+            });
             test(files, "/a/b", ["c.ts", "/a/b/b.ts"], 2, []);
         });
     });
@@ -358,11 +358,7 @@ export = C;
         function test(files: Map<string>, options: CompilerOptions, currentDirectory: string, useCaseSensitiveFileNames: boolean, rootFiles: string[], diagnosticCodes: number[]): void {
             const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
             if (!useCaseSensitiveFileNames) {
-                const f: Map<string> = {};
-                for (const fileName in files) {
-                    f[getCanonicalFileName(fileName)] = files[fileName];
-                }
-                files = f;
+                files = reduceProperties(files, (files, file, fileName) => (files[getCanonicalFileName(fileName)] = file, files), createMap<string>());
             }
 
             const host: CompilerHost = {
@@ -371,7 +367,7 @@ export = C;
                         return library;
                     }
                     const path = getCanonicalFileName(normalizePath(combinePaths(currentDirectory, fileName)));
-                    return hasProperty(files, path) ? createSourceFile(fileName, files[path], languageVersion) : undefined;
+                    return path in files ? createSourceFile(fileName, files[path], languageVersion) : undefined;
                 },
                 getDefaultLibFileName: () => "lib.d.ts",
                 writeFile: (fileName, content): void => { throw new Error("NotImplemented"); },
@@ -382,7 +378,7 @@ export = C;
                 useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
                 fileExists: fileName => {
                     const path = getCanonicalFileName(normalizePath(combinePaths(currentDirectory, fileName)));
-                    return hasProperty(files, path);
+                    return path in files;
                 },
                 readFile: (fileName): string => { throw new Error("NotImplemented"); }
             };
@@ -395,77 +391,77 @@ export = C;
         }
 
         it("should succeed when the same file is referenced using absolute and relative names", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/b/c.ts": `/// <reference path="d.ts"/>`,
                 "/a/b/d.ts": "var x"
-            };
+            });
             test(files, { module: ts.ModuleKind.AMD },  "/a/b", /*useCaseSensitiveFileNames*/ false, ["c.ts", "/a/b/d.ts"], []);
         });
 
         it("should fail when two files used in program differ only in casing (tripleslash references)", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/b/c.ts": `/// <reference path="D.ts"/>`,
                 "/a/b/d.ts": "var x"
-            };
+            });
             test(files, { module: ts.ModuleKind.AMD, forceConsistentCasingInFileNames: true },  "/a/b", /*useCaseSensitiveFileNames*/ false, ["c.ts", "d.ts"], [1149]);
         });
 
         it("should fail when two files used in program differ only in casing (imports)", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/b/c.ts": `import {x} from "D"`,
                 "/a/b/d.ts": "export var x"
-            };
+            });
             test(files, { module: ts.ModuleKind.AMD, forceConsistentCasingInFileNames: true },  "/a/b", /*useCaseSensitiveFileNames*/ false, ["c.ts", "d.ts"], [1149]);
         });
 
         it("should fail when two files used in program differ only in casing (imports, relative module names)", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "moduleA.ts": `import {x} from "./ModuleB"`,
                 "moduleB.ts": "export var x"
-            };
+            });
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "", /*useCaseSensitiveFileNames*/ false, ["moduleA.ts", "moduleB.ts"], [1149]);
         });
 
         it("should fail when two files exist on disk that differs only in casing", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/b/c.ts": `import {x} from "D"`,
                 "/a/b/D.ts": "export var x",
                 "/a/b/d.ts": "export var y"
-            };
+            });
             test(files, { module: ts.ModuleKind.AMD },  "/a/b", /*useCaseSensitiveFileNames*/ true, ["c.ts", "d.ts"], [1149]);
         });
 
         it("should fail when module name in 'require' calls has inconsistent casing", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "moduleA.ts": `import a = require("./ModuleC")`,
                 "moduleB.ts": `import a = require("./moduleC")`,
                 "moduleC.ts": "export var x"
-            };
+            });
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "", /*useCaseSensitiveFileNames*/ false, ["moduleA.ts", "moduleB.ts", "moduleC.ts"], [1149, 1149]);
         });
 
         it("should fail when module names in 'require' calls has inconsistent casing and current directory has uppercase chars", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/B/c/moduleA.ts": `import a = require("./ModuleC")`,
                 "/a/B/c/moduleB.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleC.ts": "export var x",
                 "/a/B/c/moduleD.ts": `
-import a = require("./moduleA.ts");
-import b = require("./moduleB.ts");
+import a = require("./moduleA");
+import b = require("./moduleB");
                 `
-            };
+            });
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "/a/B/c", /*useCaseSensitiveFileNames*/ false, ["moduleD.ts"], [1149]);
         });
         it("should not fail when module names in 'require' calls has consistent casing and current directory has uppercase chars", () => {
-            const files: Map<string> = {
+            const files = createMap({
                 "/a/B/c/moduleA.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleB.ts": `import a = require("./moduleC")`,
                 "/a/B/c/moduleC.ts": "export var x",
                 "/a/B/c/moduleD.ts": `
-import a = require("./moduleA.ts");
-import b = require("./moduleB.ts");
+import a = require("./moduleA");
+import b = require("./moduleB");
                 `
-            };
+            });
             test(files, { module: ts.ModuleKind.CommonJS, forceConsistentCasingInFileNames: true },  "/a/B/c", /*useCaseSensitiveFileNames*/ false, ["moduleD.ts"], []);
         });
     });
@@ -1023,7 +1019,7 @@ import b = require("./moduleB.ts");
             const names = map(files, f => f.name);
             const sourceFiles = arrayToMap(map(files, f => createSourceFile(f.name, f.content, ScriptTarget.ES6)), f => f.fileName);
             const compilerHost: CompilerHost = {
-                fileExists : fileName => hasProperty(sourceFiles, fileName),
+                fileExists : fileName => fileName in sourceFiles,
                 getSourceFile: fileName => sourceFiles[fileName],
                 getDefaultLibFileName: () => "lib.d.ts",
                 writeFile(file, text) {
@@ -1034,7 +1030,7 @@ import b = require("./moduleB.ts");
                 getCanonicalFileName: f => f.toLowerCase(),
                 getNewLine: () => "\r\n",
                 useCaseSensitiveFileNames: () => false,
-                readFile: fileName => hasProperty(sourceFiles, fileName) ? sourceFiles[fileName].text : undefined
+                readFile: fileName => fileName in sourceFiles ? sourceFiles[fileName].text : undefined
             };
             const program1 = createProgram(names, {}, compilerHost);
             const diagnostics1 = program1.getFileProcessingDiagnostics().getDiagnostics();
diff --git a/src/harness/unittests/reuseProgramStructure.ts b/src/harness/unittests/reuseProgramStructure.ts
index 8b2b15c15b30d..60687d34c55af 100644
--- a/src/harness/unittests/reuseProgramStructure.ts
+++ b/src/harness/unittests/reuseProgramStructure.ts
@@ -95,13 +95,14 @@ namespace ts {
         }
     }
 
+    function createSourceFileWithText(fileName: string, sourceText: SourceText, target: ScriptTarget) {
+        const file = <SourceFileWithText>createSourceFile(fileName, sourceText.getFullText(), target);
+        file.sourceText = sourceText;
+        return file;
+    }
+
     function createTestCompilerHost(texts: NamedSourceText[], target: ScriptTarget): CompilerHost {
-        const files: Map<SourceFileWithText> = {};
-        for (const t of texts) {
-            const file = <SourceFileWithText>createSourceFile(t.name, t.text.getFullText(), target);
-            file.sourceText = t.text;
-            files[t.name] = file;
-        }
+        const files = arrayToMap(texts, t => t.name, t => createSourceFileWithText(t.name, t.text, target));
 
         return {
             getSourceFile(fileName): SourceFile {
@@ -128,10 +129,9 @@ namespace ts {
             getNewLine(): string {
                 return sys ? sys.newLine : newLine;
             },
-            fileExists: fileName => hasProperty(files, fileName),
+            fileExists: fileName => fileName in files,
             readFile: fileName => {
-                const file = lookUp(files, fileName);
-                return file && file.text;
+                return fileName in files ? files[fileName].text : undefined;
             }
         };
     }
@@ -152,29 +152,29 @@ namespace ts {
         return program;
     }
 
-    function getSizeOfMap(map: Map<any>): number {
-        let size = 0;
-        for (const id in map) {
-            if (hasProperty(map, id)) {
-                size++;
+    function checkResolvedModule(expected: ResolvedModule, actual: ResolvedModule): boolean {
+        if (!expected === !actual) {
+            if (expected) {
+                assert.isTrue(expected.resolvedFileName === actual.resolvedFileName, `'resolvedFileName': expected '${expected.resolvedFileName}' to be equal to '${actual.resolvedFileName}'`);
+                assert.isTrue(expected.isExternalLibraryImport === actual.isExternalLibraryImport, `'isExternalLibraryImport': expected '${expected.isExternalLibraryImport}' to be equal to '${actual.isExternalLibraryImport}'`);
             }
+            return true;
         }
-        return size;
-    }
-
-    function checkResolvedModule(expected: ResolvedModule, actual: ResolvedModule): void {
-        assert.isTrue(actual !== undefined);
-        assert.isTrue(expected.resolvedFileName === actual.resolvedFileName, `'resolvedFileName': expected '${expected.resolvedFileName}' to be equal to '${actual.resolvedFileName}'`);
-        assert.isTrue(expected.isExternalLibraryImport === actual.isExternalLibraryImport, `'isExternalLibraryImport': expected '${expected.isExternalLibraryImport}' to be equal to '${actual.isExternalLibraryImport}'`);
+        return false;
     }
 
-    function checkResolvedTypeDirective(expected: ResolvedTypeReferenceDirective, actual: ResolvedTypeReferenceDirective): void {
-        assert.isTrue(actual !== undefined);
-        assert.isTrue(expected.resolvedFileName === actual.resolvedFileName, `'resolvedFileName': expected '${expected.resolvedFileName}' to be equal to '${actual.resolvedFileName}'`);
-        assert.isTrue(expected.primary === actual.primary, `'primary': expected '${expected.primary}' to be equal to '${actual.primary}'`);
+    function checkResolvedTypeDirective(expected: ResolvedTypeReferenceDirective, actual: ResolvedTypeReferenceDirective): boolean {
+        if (!expected === !actual) {
+            if (expected) {
+                assert.isTrue(expected.resolvedFileName === actual.resolvedFileName, `'resolvedFileName': expected '${expected.resolvedFileName}' to be equal to '${actual.resolvedFileName}'`);
+                assert.isTrue(expected.primary === actual.primary, `'primary': expected '${expected.primary}' to be equal to '${actual.primary}'`);
+            }
+            return true;
+        }
+        return false;
     }
 
-    function checkCache<T>(caption: string, program: Program, fileName: string, expectedContent: Map<T>, getCache: (f: SourceFile) => Map<T>, entryChecker: (expected: T, original: T) => void): void {
+    function checkCache<T>(caption: string, program: Program, fileName: string, expectedContent: Map<T>, getCache: (f: SourceFile) => Map<T>, entryChecker: (expected: T, original: T) => boolean): void {
         const file = program.getSourceFile(fileName);
         assert.isTrue(file !== undefined, `cannot find file ${fileName}`);
         const cache = getCache(file);
@@ -183,23 +183,7 @@ namespace ts {
         }
         else {
             assert.isTrue(cache !== undefined, `expected ${caption} to be set`);
-            const actualCacheSize = getSizeOfMap(cache);
-            const expectedSize = getSizeOfMap(expectedContent);
-            assert.isTrue(actualCacheSize === expectedSize, `expected actual size: ${actualCacheSize} to be equal to ${expectedSize}`);
-
-            for (const id in expectedContent) {
-                if (hasProperty(expectedContent, id)) {
-
-                    if (expectedContent[id]) {
-                        const expected = expectedContent[id];
-                        const actual = cache[id];
-                        entryChecker(expected, actual);
-                    }
-                }
-                else {
-                    assert.isTrue(cache[id] === undefined);
-                }
-            }
+            assert.isTrue(equalOwnProperties(expectedContent, cache, entryChecker), `contents of ${caption} did not match the expected contents.`);
         }
     }
 
@@ -313,6 +297,8 @@ namespace ts {
         });
 
         it("resolution cache follows imports", () => {
+            (<any>Error).stackTraceLimit = Infinity;
+
             const files = [
                 { name: "a.ts", text: SourceText.New("", "import {_} from 'b'", "var x = 1") },
                 { name: "b.ts", text: SourceText.New("", "", "var y = 2") },
@@ -320,7 +306,7 @@ namespace ts {
             const options: CompilerOptions = { target };
 
             const program_1 = newProgram(files, ["a.ts"], options);
-            checkResolvedModulesCache(program_1, "a.ts", { "b": { resolvedFileName: "b.ts" } });
+            checkResolvedModulesCache(program_1, "a.ts", createMap({ "b": { resolvedFileName: "b.ts" } }));
             checkResolvedModulesCache(program_1, "b.ts", undefined);
 
             const program_2 = updateProgram(program_1, ["a.ts"], options, files => {
@@ -329,7 +315,7 @@ namespace ts {
             assert.isTrue(program_1.structureIsReused);
 
             // content of resolution cache should not change
-            checkResolvedModulesCache(program_1, "a.ts", { "b": { resolvedFileName: "b.ts" } });
+            checkResolvedModulesCache(program_1, "a.ts", createMap({ "b": { resolvedFileName: "b.ts" } }));
             checkResolvedModulesCache(program_1, "b.ts", undefined);
 
             // imports has changed - program is not reused
@@ -346,7 +332,7 @@ namespace ts {
                 files[0].text = files[0].text.updateImportsAndExports(newImports);
             });
             assert.isTrue(!program_3.structureIsReused);
-            checkResolvedModulesCache(program_4, "a.ts", { "b": { resolvedFileName: "b.ts" }, "c": undefined });
+            checkResolvedModulesCache(program_4, "a.ts", createMap({ "b": { resolvedFileName: "b.ts" }, "c": undefined }));
         });
 
         it("resolved type directives cache follows type directives", () => {
@@ -357,7 +343,7 @@ namespace ts {
             const options: CompilerOptions = { target, typeRoots: ["/types"] };
 
             const program_1 = newProgram(files, ["/a.ts"], options);
-            checkResolvedTypeDirectivesCache(program_1, "/a.ts", { "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } });
+            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMap({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
             checkResolvedTypeDirectivesCache(program_1, "/types/typedefs/index.d.ts", undefined);
 
             const program_2 = updateProgram(program_1, ["/a.ts"], options, files => {
@@ -366,7 +352,7 @@ namespace ts {
             assert.isTrue(program_1.structureIsReused);
 
             // content of resolution cache should not change
-            checkResolvedTypeDirectivesCache(program_1, "/a.ts", { "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } });
+            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMap({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
             checkResolvedTypeDirectivesCache(program_1, "/types/typedefs/index.d.ts", undefined);
 
             // type reference directives has changed - program is not reused
@@ -384,7 +370,7 @@ namespace ts {
                 files[0].text = files[0].text.updateReferences(newReferences);
             });
             assert.isTrue(!program_3.structureIsReused);
-            checkResolvedTypeDirectivesCache(program_1, "/a.ts", { "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } });
+            checkResolvedTypeDirectivesCache(program_1, "/a.ts", createMap({ "typedefs": { resolvedFileName: "/types/typedefs/index.d.ts", primary: true } }));
         });
     });
 
diff --git a/src/harness/unittests/session.ts b/src/harness/unittests/session.ts
index ba3b99978fa3b..83baa20e3f7b2 100644
--- a/src/harness/unittests/session.ts
+++ b/src/harness/unittests/session.ts
@@ -107,7 +107,7 @@ namespace ts.server {
         describe("onMessage", () => {
             it("should not throw when commands are executed with invalid arguments", () => {
                 let i = 0;
-                for (name in CommandNames) {
+                for (const name in CommandNames) {
                     if (!Object.prototype.hasOwnProperty.call(CommandNames, name)) {
                         continue;
                     }
@@ -363,13 +363,13 @@ namespace ts.server {
         class InProcClient {
             private server: InProcSession;
             private seq = 0;
-            private callbacks: ts.Map<(resp: protocol.Response) => void> = {};
-            private eventHandlers: ts.Map<(args: any) => void> = {};
+            private callbacks = createMap<(resp: protocol.Response) => void>();
+            private eventHandlers = createMap<(args: any) => void>();
 
             handle(msg: protocol.Message): void {
                 if (msg.type === "response") {
                     const response = <protocol.Response>msg;
-                    if (this.callbacks[response.request_seq]) {
+                    if (response.request_seq in this.callbacks) {
                         this.callbacks[response.request_seq](response);
                         delete this.callbacks[response.request_seq];
                     }
@@ -381,7 +381,7 @@ namespace ts.server {
             }
 
             emit(name: string, args: any): void {
-                if (this.eventHandlers[name]) {
+                if (name in this.eventHandlers) {
                     this.eventHandlers[name](args);
                 }
             }
diff --git a/src/harness/unittests/transpile.ts b/src/harness/unittests/transpile.ts
index be1c2794f6395..808a5df37c15d 100644
--- a/src/harness/unittests/transpile.ts
+++ b/src/harness/unittests/transpile.ts
@@ -61,8 +61,8 @@ namespace ts {
                     oldTranspileDiagnostics = undefined;
                 });
 
-                it("Correct errors", () => {
-                    Harness.Baseline.runBaseline("Correct errors", justName.replace(/\.tsx?$/, ".errors.txt"), () => {
+                it("Correct errors for " + justName, () => {
+                    Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".errors.txt"), () => {
                         if (transpileResult.diagnostics.length === 0) {
                             /* tslint:disable:no-null-keyword */
                             return null;
@@ -74,8 +74,8 @@ namespace ts {
                 });
 
                 if (canUseOldTranspile) {
-                    it("Correct errors (old transpile)", () => {
-                        Harness.Baseline.runBaseline("Correct errors", justName.replace(/\.tsx?$/, ".oldTranspile.errors.txt"), () => {
+                    it("Correct errors (old transpile) for " + justName, () => {
+                        Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".oldTranspile.errors.txt"), () => {
                             if (oldTranspileDiagnostics.length === 0) {
                                 /* tslint:disable:no-null-keyword */
                                 return null;
@@ -87,8 +87,8 @@ namespace ts {
                     });
                 }
 
-                it("Correct output", () => {
-                    Harness.Baseline.runBaseline("Correct output", justName.replace(/\.tsx?$/, ".js"), () => {
+                it("Correct output for " + justName, () => {
+                    Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".js"), () => {
                         if (transpileResult.outputText) {
                             return transpileResult.outputText;
                         }
@@ -102,8 +102,8 @@ namespace ts {
                 });
 
                 if (canUseOldTranspile) {
-                    it("Correct output (old transpile)", () => {
-                        Harness.Baseline.runBaseline("Correct output", justName.replace(/\.tsx?$/, ".oldTranspile.js"), () => {
+                    it("Correct output (old transpile) for " + justName, () => {
+                        Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".oldTranspile.js"), () => {
                             return oldTranspileResult;
                         });
                     });
diff --git a/src/harness/unittests/tsconfigParsing.ts b/src/harness/unittests/tsconfigParsing.ts
index 557379dff3b7d..2c9bcdb84233e 100644
--- a/src/harness/unittests/tsconfigParsing.ts
+++ b/src/harness/unittests/tsconfigParsing.ts
@@ -181,5 +181,25 @@ namespace ts {
                 ["/d.ts", "/folder/e.ts"]
             );
         });
+
+        it("parse and re-emit tsconfig.json file with diagnostics", () => {
+            const content = `{
+                "compilerOptions": {
+                    "allowJs": true
+                    "outDir": "bin"
+                }
+                "files": ["file1.ts"]
+            }`;
+            const { configJsonObject, diagnostics } = parseAndReEmitConfigJSONFile(content);
+            const expectedResult = {
+                compilerOptions: {
+                    allowJs: true,
+                    outDir: "bin"
+                },
+                files: ["file1.ts"]
+            };
+            assert.isTrue(diagnostics.length === 2);
+            assert.equal(JSON.stringify(configJsonObject), JSON.stringify(expectedResult));
+        });
     });
 }
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 9ef100fd79734..c9bef7fea7b02 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/src/harness/unittests/tsserverProjectSystem.ts
@@ -68,20 +68,10 @@ namespace ts {
         return entry;
     }
 
-    function sizeOfMap(map: Map<any>): number {
-        let n = 0;
-        for (const name in map) {
-            if (hasProperty(map, name)) {
-                n++;
-            }
-        }
-        return n;
-    }
-
     function checkMapKeys(caption: string, map: Map<any>, expectedKeys: string[]) {
-        assert.equal(sizeOfMap(map), expectedKeys.length, `${caption}: incorrect size of map`);
+        assert.equal(reduceProperties(map, count => count + 1, 0), expectedKeys.length, `${caption}: incorrect size of map`);
         for (const name of expectedKeys) {
-            assert.isTrue(hasProperty(map, name), `${caption} is expected to contain ${name}, actual keys: ${getKeys(map)}`);
+            assert.isTrue(name in map, `${caption} is expected to contain ${name}, actual keys: ${Object.keys(map)}`);
         }
     }
 
@@ -126,8 +116,8 @@ namespace ts {
         private getCanonicalFileName: (s: string) => string;
         private toPath: (f: string) => Path;
         private callbackQueue: TimeOutCallback[] = [];
-        readonly watchedDirectories: Map<{ cb: DirectoryWatcherCallback, recursive: boolean }[]> = {};
-        readonly watchedFiles: Map<FileWatcherCallback[]> = {};
+        readonly watchedDirectories = createMap<{ cb: DirectoryWatcherCallback, recursive: boolean }[]>();
+        readonly watchedFiles = createMap<FileWatcherCallback[]>();
 
         constructor(public useCaseSensitiveFileNames: boolean, private executingFilePath: string, private currentDirectory: string, fileOrFolderList: FileOrFolder[]) {
             this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
@@ -208,7 +198,7 @@ namespace ts {
 
         watchDirectory(directoryName: string, callback: DirectoryWatcherCallback, recursive: boolean): DirectoryWatcher {
             const path = this.toPath(directoryName);
-            const callbacks = lookUp(this.watchedDirectories, path) || (this.watchedDirectories[path] = []);
+            const callbacks = this.watchedDirectories[path] || (this.watchedDirectories[path] = []);
             callbacks.push({ cb: callback, recursive });
             return {
                 referenceCount: 0,
@@ -229,7 +219,7 @@ namespace ts {
 
         triggerDirectoryWatcherCallback(directoryName: string, fileName: string): void {
             const path = this.toPath(directoryName);
-            const callbacks = lookUp(this.watchedDirectories, path);
+            const callbacks = this.watchedDirectories[path];
             if (callbacks) {
                 for (const callback of callbacks) {
                     callback.cb(fileName);
@@ -239,7 +229,7 @@ namespace ts {
 
         triggerFileWatcherCallback(fileName: string, removed?: boolean): void {
             const path = this.toPath(fileName);
-            const callbacks = lookUp(this.watchedFiles, path);
+            const callbacks = this.watchedFiles[path];
             if (callbacks) {
                 for (const callback of callbacks) {
                     callback(path, removed);
@@ -249,7 +239,7 @@ namespace ts {
 
         watchFile(fileName: string, callback: FileWatcherCallback) {
             const path = this.toPath(fileName);
-            const callbacks = lookUp(this.watchedFiles, path) || (this.watchedFiles[path] = []);
+            const callbacks = this.watchedFiles[path] || (this.watchedFiles[path] = []);
             callbacks.push(callback);
             return {
                 close: () => {
@@ -596,7 +586,7 @@ namespace ts {
                 content: `{
                     "compilerOptions": {
                         "target": "es6"
-                    }, 
+                    },
                     "files": [ "main.ts" ]
                 }`
             };
@@ -623,7 +613,7 @@ namespace ts {
                 content: `{
                     "compilerOptions": {
                         "target": "es6"
-                    }, 
+                    },
                     "files": [ "main.ts" ]
                 }`
             };
@@ -635,5 +625,23 @@ namespace ts {
             checkNumberOfConfiguredProjects(projectService, 1);
             checkNumberOfInferredProjects(projectService, 0);
         });
+
+        it("should tolerate config file errors and still try to build a project", () => {
+            const configFile: FileOrFolder = {
+                path: "/a/b/tsconfig.json",
+                content: `{
+                    "compilerOptions": {
+                        "target": "es6",
+                        "allowAnything": true
+                    },
+                    "someOtherProperty": {}
+                }`
+            };
+            const host = new TestServerHost(/*useCaseSensitiveFileNames*/ false, getExecutingFilePathFromLibFile(libFile), "/", [commonFile1, commonFile2, libFile, configFile]);
+            const projectService = new server.ProjectService(host, nullLogger);
+            projectService.openClientFile(commonFile1.path);
+            checkNumberOfConfiguredProjects(projectService, 1);
+            checkConfiguredProjectRootFiles(projectService.configuredProjects[0], [commonFile1.path, commonFile2.path]);
+        });
     });
 }
\ No newline at end of file
diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts
index d2938f6e983dc..ee657f64a65c3 100644
--- a/src/lib/dom.generated.d.ts
+++ b/src/lib/dom.generated.d.ts
@@ -126,6 +126,7 @@ interface KeyAlgorithm {
 }
 
 interface KeyboardEventInit extends EventModifierInit {
+    code?: string;
     key?: string;
     location?: number;
     repeat?: boolean;
@@ -2288,7 +2289,7 @@ declare var DeviceRotationRate: {
     new(): DeviceRotationRate;
 }
 
-interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
+interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent, ParentNode {
     /**
       * Sets or gets the URL for the current document. 
       */
@@ -3351,7 +3352,7 @@ declare var Document: {
     new(): Document;
 }
 
-interface DocumentFragment extends Node, NodeSelector {
+interface DocumentFragment extends Node, NodeSelector, ParentNode {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -3420,7 +3421,7 @@ declare var EXT_texture_filter_anisotropic: {
     readonly TEXTURE_MAX_ANISOTROPY_EXT: number;
 }
 
-interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode {
+interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode, ParentNode {
     readonly classList: DOMTokenList;
     className: string;
     readonly clientHeight: number;
@@ -3675,6 +3676,16 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     getElementsByClassName(classNames: string): NodeListOf<Element>;
     matches(selector: string): boolean;
     closest(selector: string): Element | null;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element | null;
+    insertAdjacentHTML(where: string, html: string): void;
+    insertAdjacentText(where: string, text: string): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -4446,7 +4457,7 @@ interface HTMLCanvasElement extends HTMLElement {
       * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
       */
     toDataURL(type?: string, ...args: any[]): string;
-    toBlob(callback: (result: Blob | null) => void, ... arguments: any[]): void;
+    toBlob(callback: (result: Blob | null) => void, type?: string, ...arguments: any[]): void;
 }
 
 declare var HTMLCanvasElement: {
@@ -4621,11 +4632,7 @@ interface HTMLElement extends Element {
     click(): void;
     dragDrop(): boolean;
     focus(): void;
-    insertAdjacentElement(position: string, insertedElement: Element): Element;
-    insertAdjacentHTML(where: string, html: string): void;
-    insertAdjacentText(where: string, text: string): void;
     msGetInputContext(): MSInputMethodContext;
-    scrollIntoView(top?: boolean): void;
     setActive(): void;
     addEventListener(type: "MSContentZoom", listener: (this: this, ev: UIEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -5890,6 +5897,7 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle {
       */
     type: string;
     import?: Document;
+    integrity: string;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -6178,7 +6186,7 @@ interface HTMLMediaElement extends HTMLElement {
       */
     canPlayType(type: string): string;
     /**
-      * Fires immediately after the client loads the object.
+      * Resets the audio or video object and loads a new media resource.
       */
     load(): void;
     /**
@@ -6751,6 +6759,7 @@ interface HTMLScriptElement extends HTMLElement {
       * Sets or retrieves the MIME type for the associated scripting engine.
       */
     type: string;
+    integrity: string;
 }
 
 declare var HTMLScriptElement: {
@@ -7756,6 +7765,7 @@ interface KeyboardEvent extends UIEvent {
     readonly repeat: boolean;
     readonly shiftKey: boolean;
     readonly which: number;
+    readonly code: string;
     getModifierState(keyArg: string): boolean;
     initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     readonly DOM_KEY_LOCATION_JOYSTICK: number;
@@ -9128,6 +9138,7 @@ interface PerformanceTiming {
     readonly responseStart: number;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
+    readonly secureConnectionStart: number;
     toJSON(): any;
 }
 
@@ -11405,8 +11416,8 @@ declare var StereoPannerNode: {
 interface Storage {
     readonly length: number;
     clear(): void;
-    getItem(key: string): string;
-    key(index: number): string;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
     removeItem(key: string): void;
     setItem(key: string, data: string): void;
     [key: string]: any;
@@ -12947,7 +12958,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onunload: (this: this, ev: Event) => any;
     onvolumechange: (this: this, ev: Event) => any;
     onwaiting: (this: this, ev: Event) => any;
-    readonly opener: Window;
+    opener: any;
     orientation: string | number;
     readonly outerHeight: number;
     readonly outerWidth: number;
@@ -13002,6 +13013,9 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    scroll(options?: ScrollToOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollBy(options?: ScrollToOptions): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -14029,6 +14043,20 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+interface ScrollOptions {
+    behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+    left?: number;
+    top?: number;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+}
+
 interface ClipboardEventInit extends EventInit {
     data?: string;
     dataType?: string;
@@ -14072,7 +14100,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
@@ -14208,6 +14236,13 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface ParentNode {
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    readonly childElementCount: number;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -14278,7 +14313,7 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msCredentials: MSCredentials;
-declare var name: string;
+declare const name: never;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
 declare var onabort: (this: Window, ev: UIEvent) => any;
@@ -14372,7 +14407,7 @@ declare var ontouchstart: (ev: TouchEvent) => any;
 declare var onunload: (this: Window, ev: Event) => any;
 declare var onvolumechange: (this: Window, ev: Event) => any;
 declare var onwaiting: (this: Window, ev: Event) => any;
-declare var opener: Window;
+declare var opener: any;
 declare var orientation: string | number;
 declare var outerHeight: number;
 declare var outerWidth: number;
@@ -14425,6 +14460,9 @@ declare function webkitCancelAnimationFrame(handle: number): void;
 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function scroll(options?: ScrollToOptions): void;
+declare function scrollTo(options?: ScrollToOptions): void;
+declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 declare function dispatchEvent(evt: Event): boolean;
@@ -14580,6 +14618,8 @@ type MSOutboundPayload = MSVideoSendPayload | MSAudioSendPayload;
 type RTCIceGatherCandidate = RTCIceCandidate | RTCIceCandidateComplete;
 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
 type payloadtype = number;
+type ScrollBehavior = "auto" | "instant" | "smooth";
+type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
 type MouseWheelEvent = WheelEvent;
\ No newline at end of file
diff --git a/src/lib/es2015.core.d.ts b/src/lib/es2015.core.d.ts
index fef0b0ce3ce19..15fbb1b77c5ee 100644
--- a/src/lib/es2015.core.d.ts
+++ b/src/lib/es2015.core.d.ts
@@ -68,6 +68,10 @@ interface ArrayConstructor {
     of<T>(...items: T[]): Array<T>;
 }
 
+interface DateConstructor {
+    new (value: Date): Date;
+}
+
 interface Function {
     /**
       * Returns the name of the function. Function names are read-only and can not be changed.
@@ -343,6 +347,30 @@ interface ObjectConstructor {
     defineProperty(o: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): any;
 }
 
+interface ReadonlyArray<T> {
+  /**
+    * Returns the value of the first element in the array where predicate is true, and undefined
+    * otherwise.
+    * @param predicate find calls predicate once for each element of the array, in ascending
+    * order, until it finds one where predicate returns true. If such an element is found, find
+    * immediately returns that element value. Otherwise, find returns undefined.
+    * @param thisArg If provided, it will be used as the this value for each invocation of
+    * predicate. If it is not provided, undefined is used instead.
+    */
+  find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): T | undefined;
+
+  /**
+    * Returns the index of the first element in the array where predicate is true, and undefined
+    * otherwise.
+    * @param predicate find calls predicate once for each element of the array, in ascending
+    * order, until it finds one where predicate returns true. If such an element is found, 
+    * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+    * @param thisArg If provided, it will be used as the this value for each invocation of
+    * predicate. If it is not provided, undefined is used instead.
+    */
+  findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
+}
+
 interface RegExp {
     /**
       * Returns a string indicating the flags of the regular expression in question. This field is read-only.
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index e1b9d99762bce..de339e2bf2cc4 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -63,6 +63,26 @@ interface ArrayConstructor {
     from<T>(iterable: Iterable<T>): Array<T>;
 }
 
+interface ReadonlyArray<T> {
+    /** Iterator */
+    [Symbol.iterator](): IterableIterator<T>;
+
+    /** 
+      * Returns an array of key, value pairs for every entry in the array
+      */
+    entries(): IterableIterator<[number, T]>;
+
+    /** 
+      * Returns an list of keys in the array
+      */
+    keys(): IterableIterator<number>;
+
+    /** 
+      * Returns an list of values in the array
+      */
+    values(): IterableIterator<T>;
+}
+
 interface IArguments {
     /** Iterator */
     [Symbol.iterator](): IterableIterator<any>;
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 496df578c1911..e4cbe323c681a 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1006,7 +1006,12 @@ interface ReadonlyArray<T> {
       * Combines two or more arrays.
       * @param items Additional items to add to the end of array1.
       */
-    concat(...items: T[]): T[];
+    concat(...items: T[][]): T[];
+    /**
+      * Combines two or more arrays.
+      * @param items Additional items to add to the end of array1.
+      */
+    concat(...items: (T | T[])[]): T[];
     /**
       * Adds all the elements of an array separated by the specified separator string.
       * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts
index c61a1a8b8a600..483348f3f750e 100644
--- a/src/lib/webworker.generated.d.ts
+++ b/src/lib/webworker.generated.d.ts
@@ -1000,7 +1000,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
diff --git a/src/server/client.ts b/src/server/client.ts
index f04dbd8dc0253..88177e91fad7b 100644
--- a/src/server/client.ts
+++ b/src/server/client.ts
@@ -21,7 +21,7 @@ namespace ts.server {
 
     export class SessionClient implements LanguageService {
         private sequence: number = 0;
-        private lineMaps: ts.Map<number[]> = {};
+        private lineMaps: ts.Map<number[]> = ts.createMap<number[]>();
         private messages: string[] = [];
         private lastRenameEntry: RenameEntry;
 
@@ -37,7 +37,7 @@ namespace ts.server {
         }
 
         private getLineMap(fileName: string): number[] {
-            let lineMap = ts.lookUp(this.lineMaps, fileName);
+            let lineMap = this.lineMaps[fileName];
             if (!lineMap) {
                 const scriptSnapshot = this.host.getScriptSnapshot(fileName);
                 lineMap = this.lineMaps[fileName] = ts.computeLineStarts(scriptSnapshot.getText(0, scriptSnapshot.getLength()));
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 6e9adad7f472f..255ad8547ea48 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -130,15 +130,15 @@ namespace ts.server {
             const path = toPath(containingFile, this.host.getCurrentDirectory(), this.getCanonicalFileName);
             const currentResolutionsInFile = cache.get(path);
 
-            const newResolutions: Map<T> = {};
+            const newResolutions = createMap<T>();
             const resolvedModules: R[] = [];
             const compilerOptions = this.getCompilationSettings();
 
             for (const name of names) {
                 // check if this is a duplicate entry in the list
-                let resolution = lookUp(newResolutions, name);
+                let resolution = newResolutions[name];
                 if (!resolution) {
-                    const existingResolution = currentResolutionsInFile && ts.lookUp(currentResolutionsInFile, name);
+                    const existingResolution = currentResolutionsInFile && currentResolutionsInFile[name];
                     if (moduleResolutionIsValid(existingResolution)) {
                         // ok, it is safe to use existing name resolution results
                         resolution = existingResolution;
@@ -378,7 +378,7 @@ namespace ts.server {
     export interface ProjectOptions {
         // these fields can be present in the project file
         files?: string[];
-        wildcardDirectories?: ts.Map<ts.WatchDirectoryFlags>;
+        wildcardDirectories?: ts.MapLike<ts.WatchDirectoryFlags>;
         compilerOptions?: ts.CompilerOptions;
     }
 
@@ -391,7 +391,7 @@ namespace ts.server {
         // Used to keep track of what directories are watched for this project
         directoriesWatchedForTsconfig: string[] = [];
         program: ts.Program;
-        filenameToSourceFile: ts.Map<ts.SourceFile> = {};
+        filenameToSourceFile = ts.createMap<ts.SourceFile>();
         updateGraphSeq = 0;
         /** Used for configured projects which may have multiple open roots */
         openRefCount = 0;
@@ -504,7 +504,7 @@ namespace ts.server {
                 return;
             }
 
-            this.filenameToSourceFile = {};
+            this.filenameToSourceFile = createMap<SourceFile>();
             const sourceFiles = this.program.getSourceFiles();
             for (let i = 0, len = sourceFiles.length; i < len; i++) {
                 const normFilename = ts.normalizePath(sourceFiles[i].fileName);
@@ -563,7 +563,7 @@ namespace ts.server {
             }
 
             let strBuilder = "";
-            ts.forEachValue(this.filenameToSourceFile,
+            ts.forEachProperty(this.filenameToSourceFile,
                 sourceFile => { strBuilder += sourceFile.fileName + "\n"; });
             return strBuilder;
         }
@@ -603,8 +603,11 @@ namespace ts.server {
         return projects.length > 1 ? deduplicate(result, areEqual) : result;
     }
 
+    export type ProjectServiceEvent =
+        { eventName: "context", data: { project: Project, fileName: string } } | { eventName: "configFileDiag", data: { triggerFile?: string, configFileName: string, diagnostics: Diagnostic[] } }
+
     export interface ProjectServiceEventHandler {
-        (eventName: string, project: Project, fileName: string): void;
+        (event: ProjectServiceEvent): void;
     }
 
     export interface HostConfiguration {
@@ -613,7 +616,7 @@ namespace ts.server {
     }
 
     export class ProjectService {
-        filenameToScriptInfo: ts.Map<ScriptInfo> = {};
+        filenameToScriptInfo = ts.createMap<ScriptInfo>();
         // open, non-configured root files
         openFileRoots: ScriptInfo[] = [];
         // projects built from openFileRoots
@@ -625,12 +628,12 @@ namespace ts.server {
         // open files that are roots of a configured project
         openFileRootsConfigured: ScriptInfo[] = [];
         // a path to directory watcher map that detects added tsconfig files
-        directoryWatchersForTsconfig: ts.Map<FileWatcher> = {};
+        directoryWatchersForTsconfig = ts.createMap<FileWatcher>();
         // count of how many projects are using the directory watcher. If the
         // number becomes 0 for a watcher, then we should close it.
-        directoryWatchersRefCount: ts.Map<number> = {};
+        directoryWatchersRefCount = ts.createMap<number>();
         hostConfiguration: HostConfiguration;
-        timerForDetectingProjectFileListChanges: Map<any> = {};
+        timerForDetectingProjectFileListChanges = createMap<any>();
 
         constructor(public host: ServerHost, public psLogger: Logger, public eventHandler?: ProjectServiceEventHandler) {
             // ts.disableIncrementalParsing = true;
@@ -699,7 +702,8 @@ namespace ts.server {
         }
 
         handleProjectFileListChanges(project: Project) {
-            const { projectOptions } = this.configFileToProjectOptions(project.projectFilename);
+            const { projectOptions, errors } = this.configFileToProjectOptions(project.projectFilename);
+            this.reportConfigFileDiagnostics(project.projectFilename, errors);
 
             const newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));
             const currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));
@@ -717,18 +721,32 @@ namespace ts.server {
             }
         }
 
+        reportConfigFileDiagnostics(configFileName: string, diagnostics: Diagnostic[], triggerFile?: string) {
+            if (diagnostics && diagnostics.length > 0) {
+                this.eventHandler({
+                    eventName: "configFileDiag",
+                    data: { configFileName, diagnostics, triggerFile }
+                });
+            }
+        }
+
         /**
          * This is the callback function when a watched directory has an added tsconfig file.
          */
         directoryWatchedForTsconfigChanged(fileName: string) {
-            if (ts.getBaseFileName(fileName) != "tsconfig.json") {
+            if (ts.getBaseFileName(fileName) !== "tsconfig.json") {
                 this.log(fileName + " is not tsconfig.json");
                 return;
             }
 
             this.log("Detected newly added tsconfig file: " + fileName);
 
-            const { projectOptions } = this.configFileToProjectOptions(fileName);
+            const { projectOptions, errors } = this.configFileToProjectOptions(fileName);
+            this.reportConfigFileDiagnostics(fileName, errors);
+
+            if (!projectOptions) {
+                return;
+            }
 
             const rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));
             const openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));
@@ -748,10 +766,13 @@ namespace ts.server {
             return ts.normalizePath(name);
         }
 
-        watchedProjectConfigFileChanged(project: Project) {
+        watchedProjectConfigFileChanged(project: Project): void {
             this.log("Config file changed: " + project.projectFilename);
-            this.updateConfiguredProject(project);
+            const configFileErrors = this.updateConfiguredProject(project);
             this.updateProjectStructure();
+            if (configFileErrors && configFileErrors.length > 0) {
+                this.eventHandler({ eventName: "configFileDiag", data: { triggerFile: project.projectFilename, configFileName: project.projectFilename, diagnostics: configFileErrors } });
+            }
         }
 
         log(msg: string, type = "Err") {
@@ -828,13 +849,13 @@ namespace ts.server {
                 for (let j = 0, flen = this.openFileRoots.length; j < flen; j++) {
                     const openFile = this.openFileRoots[j];
                     if (this.eventHandler) {
-                        this.eventHandler("context", openFile.defaultProject, openFile.fileName);
+                        this.eventHandler({ eventName: "context", data: { project: openFile.defaultProject, fileName: openFile.fileName } });
                     }
                 }
                 for (let j = 0, flen = this.openFilesReferenced.length; j < flen; j++) {
                     const openFile = this.openFilesReferenced[j];
                     if (this.eventHandler) {
-                        this.eventHandler("context", openFile.defaultProject, openFile.fileName);
+                        this.eventHandler({ eventName: "context", data: { project: openFile.defaultProject, fileName: openFile.fileName } });
                     }
                 }
             }
@@ -857,7 +878,7 @@ namespace ts.server {
             if (project.isConfiguredProject()) {
                 project.projectFileWatcher.close();
                 project.directoryWatcher.close();
-                forEachValue(project.directoriesWatchedForWildcards, watcher => { watcher.close(); });
+                forEachProperty(project.directoriesWatchedForWildcards, watcher => { watcher.close(); });
                 delete project.directoriesWatchedForWildcards;
                 this.configuredProjects = copyListRemovingItem(project, this.configuredProjects);
             }
@@ -1124,7 +1145,7 @@ namespace ts.server {
 
         getScriptInfo(filename: string) {
             filename = ts.normalizePath(filename);
-            return ts.lookUp(this.filenameToScriptInfo, filename);
+            return this.filenameToScriptInfo[filename];
         }
 
         /**
@@ -1133,7 +1154,7 @@ namespace ts.server {
          */
         openFile(fileName: string, openedByClient: boolean, fileContent?: string, scriptKind?: ScriptKind) {
             fileName = ts.normalizePath(fileName);
-            let info = ts.lookUp(this.filenameToScriptInfo, fileName);
+            let info = this.filenameToScriptInfo[fileName];
             if (!info) {
                 let content: string;
                 if (this.host.fileExists(fileName)) {
@@ -1218,7 +1239,7 @@ namespace ts.server {
                 const project = this.findConfiguredProjectByConfigFile(configFileName);
                 if (!project) {
                     const configResult = this.openConfigFile(configFileName, fileName);
-                    if (!configResult.success) {
+                    if (!configResult.project) {
                         return { configFileName, configFileErrors: configResult.errors };
                     }
                     else {
@@ -1234,11 +1255,12 @@ namespace ts.server {
                 else {
                     this.updateConfiguredProject(project);
                 }
+                return { configFileName };
             }
             else {
                 this.log("No config files found.");
             }
-            return configFileName ? { configFileName } : {};
+            return {};
         }
 
         /**
@@ -1246,7 +1268,7 @@ namespace ts.server {
          * @param filename is absolute pathname
          */
         closeClientFile(filename: string) {
-            const info = ts.lookUp(this.filenameToScriptInfo, filename);
+            const info = this.filenameToScriptInfo[filename];
             if (info) {
                 this.closeOpenFile(info);
                 info.isOpen = false;
@@ -1255,14 +1277,14 @@ namespace ts.server {
         }
 
         getProjectForFile(filename: string) {
-            const scriptInfo = ts.lookUp(this.filenameToScriptInfo, filename);
+            const scriptInfo = this.filenameToScriptInfo[filename];
             if (scriptInfo) {
                 return scriptInfo.defaultProject;
             }
         }
 
         printProjectsForFile(filename: string) {
-            const scriptInfo = ts.lookUp(this.filenameToScriptInfo, filename);
+            const scriptInfo = this.filenameToScriptInfo[filename];
             if (scriptInfo) {
                 this.psLogger.startGroup();
                 this.psLogger.info("Projects for " + filename);
@@ -1328,34 +1350,31 @@ namespace ts.server {
             return undefined;
         }
 
-        configFileToProjectOptions(configFilename: string): { succeeded: boolean, projectOptions?: ProjectOptions, errors?: Diagnostic[] } {
+        configFileToProjectOptions(configFilename: string): { projectOptions?: ProjectOptions, errors: Diagnostic[] } {
             configFilename = ts.normalizePath(configFilename);
+            let errors: Diagnostic[] = [];
             // file references will be relative to dirPath (or absolute)
             const dirPath = ts.getDirectoryPath(configFilename);
             const contents = this.host.readFile(configFilename);
-            const rawConfig: { config?: ProjectOptions; error?: Diagnostic; } = ts.parseConfigFileTextToJson(configFilename, contents);
-            if (rawConfig.error) {
-                return { succeeded: false, errors: [rawConfig.error] };
+            const { configJsonObject, diagnostics } = ts.parseAndReEmitConfigJSONFile(contents);
+            errors = concatenate(errors, diagnostics);
+            const parsedCommandLine = ts.parseJsonConfigFileContent(configJsonObject, this.host, dirPath, /*existingOptions*/ {}, configFilename);
+            errors = concatenate(errors, parsedCommandLine.errors);
+            Debug.assert(!!parsedCommandLine.fileNames);
+
+            if (parsedCommandLine.fileNames.length === 0) {
+                errors.push(createCompilerDiagnostic(Diagnostics.The_config_file_0_found_doesn_t_contain_any_source_files, configFilename));
+                return { errors };
             }
             else {
-                const parsedCommandLine = ts.parseJsonConfigFileContent(rawConfig.config, this.host, dirPath, /*existingOptions*/ {}, configFilename);
-                Debug.assert(!!parsedCommandLine.fileNames);
-
-                if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) {
-                    return { succeeded: false, errors: parsedCommandLine.errors };
-                }
-                else if (parsedCommandLine.fileNames.length === 0) {
-                    const error = createCompilerDiagnostic(Diagnostics.The_config_file_0_found_doesn_t_contain_any_source_files, configFilename);
-                    return { succeeded: false, errors: [error] };
-                }
-                else {
-                    const projectOptions: ProjectOptions = {
-                        files: parsedCommandLine.fileNames,
-                        wildcardDirectories: parsedCommandLine.wildcardDirectories,
-                        compilerOptions: parsedCommandLine.options,
-                    };
-                    return { succeeded: true, projectOptions };
-                }
+                // if the project has some files, we can continue with the parsed options and tolerate
+                // errors in the parsedCommandLine
+                const projectOptions: ProjectOptions = {
+                    files: parsedCommandLine.fileNames,
+                    wildcardDirectories: parsedCommandLine.wildcardDirectories,
+                    compilerOptions: parsedCommandLine.options,
+                };
+                return { projectOptions, errors };
             }
         }
 
@@ -1377,64 +1396,63 @@ namespace ts.server {
             return false;
         }
 
-        openConfigFile(configFilename: string, clientFileName?: string): { success: boolean, project?: Project, errors?: Diagnostic[] } {
-            const { succeeded, projectOptions, errors } = this.configFileToProjectOptions(configFilename);
-            if (!succeeded) {
-                return { success: false, errors };
+        openConfigFile(configFilename: string, clientFileName?: string): { project?: Project, errors: Diagnostic[] } {
+            const parseConfigFileResult = this.configFileToProjectOptions(configFilename);
+            let errors = parseConfigFileResult.errors;
+            if (!parseConfigFileResult.projectOptions) {
+                return { errors };
             }
-            else {
-                if (!projectOptions.compilerOptions.disableSizeLimit && projectOptions.compilerOptions.allowJs) {
-                    if (this.exceedTotalNonTsFileSizeLimit(projectOptions.files)) {
-                        const project = this.createProject(configFilename, projectOptions, /*languageServiceDisabled*/ true);
-
-                        // for configured projects with languageService disabled, we only watch its config file,
-                        // do not care about the directory changes in the folder.
-                        project.projectFileWatcher = this.host.watchFile(
-                            toPath(configFilename, configFilename, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)),
-                            _ => this.watchedProjectConfigFileChanged(project));
-                        return { success: true, project };
-                    }
+            const projectOptions = parseConfigFileResult.projectOptions;
+            if (!projectOptions.compilerOptions.disableSizeLimit && projectOptions.compilerOptions.allowJs) {
+                if (this.exceedTotalNonTsFileSizeLimit(projectOptions.files)) {
+                    const project = this.createProject(configFilename, projectOptions, /*languageServiceDisabled*/ true);
+
+                    // for configured projects with languageService disabled, we only watch its config file,
+                    // do not care about the directory changes in the folder.
+                    project.projectFileWatcher = this.host.watchFile(
+                        toPath(configFilename, configFilename, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)),
+                        _ => this.watchedProjectConfigFileChanged(project));
+                    return { project, errors };
                 }
+            }
 
-                const project = this.createProject(configFilename, projectOptions);
-                let errors: Diagnostic[];
-                for (const rootFilename of projectOptions.files) {
-                    if (this.host.fileExists(rootFilename)) {
-                        const info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
-                        project.addRoot(info);
-                    }
-                    else {
-                        (errors || (errors = [])).push(createCompilerDiagnostic(Diagnostics.File_0_not_found, rootFilename));
-                    }
+            const project = this.createProject(configFilename, projectOptions);
+            for (const rootFilename of projectOptions.files) {
+                if (this.host.fileExists(rootFilename)) {
+                    const info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
+                    project.addRoot(info);
+                }
+                else {
+                    (errors || (errors = [])).push(createCompilerDiagnostic(Diagnostics.File_0_not_found, rootFilename));
                 }
-                project.finishGraph();
-                project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
+            }
+            project.finishGraph();
+            project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
 
-                const configDirectoryPath = ts.getDirectoryPath(configFilename);
+            const configDirectoryPath = ts.getDirectoryPath(configFilename);
 
-                this.log("Add recursive watcher for: " + configDirectoryPath);
-                project.directoryWatcher = this.host.watchDirectory(
-                    configDirectoryPath,
-                    path => this.directoryWatchedForSourceFilesChanged(project, path),
-                    /*recursive*/ true
-                );
+            this.log("Add recursive watcher for: " + configDirectoryPath);
+            project.directoryWatcher = this.host.watchDirectory(
+                configDirectoryPath,
+                path => this.directoryWatchedForSourceFilesChanged(project, path),
+                /*recursive*/ true
+            );
 
-                project.directoriesWatchedForWildcards = reduceProperties(projectOptions.wildcardDirectories, (watchers, flag, directory) => {
-                    if (comparePaths(configDirectoryPath, directory, ".", !this.host.useCaseSensitiveFileNames) !== Comparison.EqualTo) {
-                        const recursive = (flag & WatchDirectoryFlags.Recursive) !== 0;
-                        this.log(`Add ${ recursive ? "recursive " : ""}watcher for: ${directory}`);
-                        watchers[directory] = this.host.watchDirectory(
-                            directory,
-                            path => this.directoryWatchedForSourceFilesChanged(project, path),
-                            recursive
-                        );
-                    }
+            project.directoriesWatchedForWildcards = reduceProperties(createMap(projectOptions.wildcardDirectories), (watchers, flag, directory) => {
+                if (comparePaths(configDirectoryPath, directory, ".", !this.host.useCaseSensitiveFileNames) !== Comparison.EqualTo) {
+                    const recursive = (flag & WatchDirectoryFlags.Recursive) !== 0;
+                    this.log(`Add ${ recursive ? "recursive " : ""}watcher for: ${directory}`);
+                    watchers[directory] = this.host.watchDirectory(
+                        directory,
+                        path => this.directoryWatchedForSourceFilesChanged(project, path),
+                        recursive
+                    );
+                }
 
-                    return watchers;
-                }, <Map<FileWatcher>>{});
+                return watchers;
+            }, <Map<FileWatcher>>{});
 
-                return { success: true, project: project, errors };
-            }
+            return { project: project, errors };
         }
 
         updateConfiguredProject(project: Project): Diagnostic[] {
@@ -1443,15 +1461,15 @@ namespace ts.server {
                 this.removeProject(project);
             }
             else {
-                const { succeeded, projectOptions, errors } = this.configFileToProjectOptions(project.projectFilename);
-                if (!succeeded) {
+                const { projectOptions, errors } = this.configFileToProjectOptions(project.projectFilename);
+                if (!projectOptions) {
                     return errors;
                 }
                 else {
                     if (projectOptions.compilerOptions && !projectOptions.compilerOptions.disableSizeLimit && this.exceedTotalNonTsFileSizeLimit(projectOptions.files)) {
                         project.setProjectOptions(projectOptions);
                         if (project.languageServiceDiabled) {
-                            return;
+                            return errors;
                         }
 
                         project.disableLanguageService();
@@ -1459,7 +1477,7 @@ namespace ts.server {
                             project.directoryWatcher.close();
                             project.directoryWatcher = undefined;
                         }
-                        return;
+                        return errors;
                     }
 
                     if (project.languageServiceDiabled) {
@@ -1478,7 +1496,7 @@ namespace ts.server {
                             }
                         }
                         project.finishGraph();
-                        return;
+                        return errors;
                     }
 
                     // if the project is too large, the root files might not have been all loaded if the total
@@ -1524,6 +1542,7 @@ namespace ts.server {
                     project.setProjectOptions(projectOptions);
                     project.finishGraph();
                 }
+                return errors;
             }
         }
 
diff --git a/src/server/session.ts b/src/server/session.ts
index 7e1ca81e2af8c..00468330ffbcb 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -153,16 +153,22 @@ namespace ts.server {
             private logger: Logger
         ) {
             this.projectService =
-                new ProjectService(host, logger, (eventName, project, fileName) => {
-                    this.handleEvent(eventName, project, fileName);
+                new ProjectService(host, logger, event => {
+                    this.handleEvent(event);
                 });
         }
 
-        private handleEvent(eventName: string, project: Project, fileName: string) {
-            if (eventName == "context") {
-                this.projectService.log("got context event, updating diagnostics for" + fileName, "Info");
-                this.updateErrorCheck([{ fileName, project }], this.changeSeq,
-                    (n) => n === this.changeSeq, 100);
+        private handleEvent(event: ProjectServiceEvent) {
+            switch (event.eventName) {
+                case "context":
+                    const { project, fileName } = event.data;
+                    this.projectService.log("got context event, updating diagnostics for" + fileName, "Info");
+                    this.updateErrorCheck([{ fileName, project }], this.changeSeq,
+                        (n) => n === this.changeSeq, 100);
+                    break;
+                case "configFileDiag":
+                    const { triggerFile, configFileName, diagnostics } = event.data;
+                    this.configFileDiagnosticEvent(triggerFile, configFileName, diagnostics);
             }
         }
 
@@ -1061,7 +1067,7 @@ namespace ts.server {
             return { response, responseRequired: true };
         }
 
-        private handlers: Map<(request: protocol.Request) => { response?: any, responseRequired?: boolean }> = {
+        private handlers = createMap<(request: protocol.Request) => { response?: any, responseRequired?: boolean }>({
             [CommandNames.Exit]: () => {
                 this.exit();
                 return { responseRequired: false };
@@ -1198,9 +1204,10 @@ namespace ts.server {
                 this.reloadProjects();
                 return { responseRequired: false };
             }
-        };
+        });
+
         public addProtocolHandler(command: string, handler: (request: protocol.Request) => { response?: any, responseRequired: boolean }) {
-            if (this.handlers[command]) {
+            if (command in this.handlers) {
                 throw new Error(`Protocol handler already exists for command "${command}"`);
             }
             this.handlers[command] = handler;
diff --git a/src/server/tsconfig.library.json b/src/server/tsconfig.library.json
index 746283720bf32..af04a74d55755 100644
--- a/src/server/tsconfig.library.json
+++ b/src/server/tsconfig.library.json
@@ -10,6 +10,8 @@
         "types": []
     },
     "files": [
+        "../services/shims.ts",
+        "../services/utilities.ts",
         "editorServices.ts",
         "protocol.d.ts",
         "session.ts"
diff --git a/src/services/jsTyping.ts b/src/services/jsTyping.ts
index 3b013a4a924ac..4f0e06244d26f 100644
--- a/src/services/jsTyping.ts
+++ b/src/services/jsTyping.ts
@@ -47,7 +47,7 @@ namespace ts.JsTyping {
         { cachedTypingPaths: string[], newTypingNames: string[], filesToWatch: string[] } {
 
         // A typing name to typing file path mapping
-        const inferredTypings: Map<string> = {};
+        const inferredTypings = createMap<string>();
 
         if (!typingOptions || !typingOptions.enableAutoDiscovery) {
             return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] };
@@ -58,12 +58,7 @@ namespace ts.JsTyping {
 
         if (!safeList) {
             const result = readConfigFile(safeListPath, (path: string) => host.readFile(path));
-            if (result.config) {
-                safeList = result.config;
-            }
-            else {
-                safeList = {};
-            };
+            safeList = createMap<string>(result.config);
         }
 
         const filesToWatch: string[] = [];
@@ -93,7 +88,7 @@ namespace ts.JsTyping {
 
         // Add the cached typing locations for inferred typings that are already installed
         for (const name in packageNameToTypingLocation) {
-            if (hasProperty(inferredTypings, name) && !inferredTypings[name]) {
+            if (name in inferredTypings && !inferredTypings[name]) {
                 inferredTypings[name] = packageNameToTypingLocation[name];
             }
         }
@@ -124,7 +119,7 @@ namespace ts.JsTyping {
             }
 
             for (const typing of typingNames) {
-                if (!hasProperty(inferredTypings, typing)) {
+                if (!(typing in inferredTypings)) {
                     inferredTypings[typing] = undefined;
                 }
             }
@@ -139,16 +134,16 @@ namespace ts.JsTyping {
                 const jsonConfig: PackageJson = result.config;
                 filesToWatch.push(jsonPath);
                 if (jsonConfig.dependencies) {
-                    mergeTypings(getKeys(jsonConfig.dependencies));
+                    mergeTypings(getOwnKeys(jsonConfig.dependencies));
                 }
                 if (jsonConfig.devDependencies) {
-                    mergeTypings(getKeys(jsonConfig.devDependencies));
+                    mergeTypings(getOwnKeys(jsonConfig.devDependencies));
                 }
                 if (jsonConfig.optionalDependencies) {
-                    mergeTypings(getKeys(jsonConfig.optionalDependencies));
+                    mergeTypings(getOwnKeys(jsonConfig.optionalDependencies));
                 }
                 if (jsonConfig.peerDependencies) {
-                    mergeTypings(getKeys(jsonConfig.peerDependencies));
+                    mergeTypings(getOwnKeys(jsonConfig.peerDependencies));
                 }
             }
         }
@@ -167,7 +162,7 @@ namespace ts.JsTyping {
                 mergeTypings(cleanedTypingNames);
             }
             else {
-                mergeTypings(filter(cleanedTypingNames, f => hasProperty(safeList, f)));
+                mergeTypings(filter(cleanedTypingNames, f => f in safeList));
             }
 
             const hasJsxFile = forEach(fileNames, f => scriptKindIs(f, /*LanguageServiceHost*/ undefined, ScriptKind.JSX));
diff --git a/src/services/navigateTo.ts b/src/services/navigateTo.ts
index e9afb6925b53f..ccded188e618e 100644
--- a/src/services/navigateTo.ts
+++ b/src/services/navigateTo.ts
@@ -15,7 +15,7 @@ namespace ts.NavigateTo {
 
             const nameToDeclarations = sourceFile.getNamedDeclarations();
             for (const name in nameToDeclarations) {
-                const declarations = getProperty(nameToDeclarations, name);
+                const declarations = nameToDeclarations[name];
                 if (declarations) {
                     // First do a quick check to see if the name of the declaration matches the
                     // last portion of the (possibly) dotted name they're searching for.
diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index 32d4244eaad78..aa4f129c28636 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -234,7 +234,7 @@ namespace ts.NavigationBar {
 
     /** Merge declarations of the same kind. */
     function mergeChildren(children: NavigationBarNode[]): void {
-        const nameToItems: Map<NavigationBarNode | NavigationBarNode[]> = {};
+        const nameToItems = createMap<NavigationBarNode | NavigationBarNode[]>();
         filterMutate(children, child => {
             const decl = <Declaration>child.node;
             const name = decl.name && nodeText(decl.name);
@@ -243,7 +243,7 @@ namespace ts.NavigationBar {
                 return true;
             }
 
-            const itemsWithSameName = getProperty(nameToItems, name);
+            const itemsWithSameName = nameToItems[name];
             if (!itemsWithSameName) {
                 nameToItems[name] = child;
                 return true;
diff --git a/src/services/patternMatcher.ts b/src/services/patternMatcher.ts
index 3d20337eca775..b4f67ca056ddb 100644
--- a/src/services/patternMatcher.ts
+++ b/src/services/patternMatcher.ts
@@ -113,7 +113,7 @@ namespace ts {
         // we see the name of a module that is used everywhere, or the name of an overload).  As
         // such, we cache the information we compute about the candidate for the life of this
         // pattern matcher so we don't have to compute it multiple times.
-        const stringToWordSpans: Map<TextSpan[]> = {};
+        const stringToWordSpans = createMap<TextSpan[]>();
 
         pattern = pattern.trim();
 
@@ -188,7 +188,7 @@ namespace ts {
         }
 
         function getWordSpans(word: string): TextSpan[] {
-            if (!hasProperty(stringToWordSpans, word)) {
+            if (!(word in stringToWordSpans)) {
                 stringToWordSpans[word] = breakIntoWordSpans(word);
             }
 
diff --git a/src/services/services.ts b/src/services/services.ts
index 86661bd55035e..171532354b5a2 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -304,6 +304,10 @@ namespace ts {
                         processNode(jsDocComment);
                     }
                 }
+                // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
+                // Restoring the scanner position ensures that. 
+                pos = this.pos;
                 forEachChild(this, processNode, processNodes);
                 if (pos < this.end) {
                     this.addSyntheticNodes(children, pos, this.end);
@@ -980,7 +984,7 @@ namespace ts {
         }
 
         private computeNamedDeclarations(): Map<Declaration[]> {
-            const result: Map<Declaration[]> = {};
+            const result = createMap<Declaration[]>();
 
             forEachChild(this, visit);
 
@@ -995,7 +999,7 @@ namespace ts {
             }
 
             function getDeclarations(name: string) {
-                return getProperty(result, name) || (result[name] = []);
+                return result[name] || (result[name] = []);
             }
 
             function getDeclarationName(declaration: Declaration) {
@@ -2030,7 +2034,7 @@ namespace ts {
         fileName?: string;
         reportDiagnostics?: boolean;
         moduleName?: string;
-        renamedDependencies?: Map<string>;
+        renamedDependencies?: MapLike<string>;
     }
 
     export interface TranspileOutput {
@@ -2047,7 +2051,7 @@ namespace ts {
     function fixupCompilerOptions(options: CompilerOptions, diagnostics: Diagnostic[]): CompilerOptions {
         // Lazily create this value to fix module loading errors.
         commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
-            typeof o.type === "object" && !forEachValue(<Map<any>>o.type, v => typeof v !== "number"));
+            typeof o.type === "object" && !forEachProperty(o.type, v => typeof v !== "number"));
 
         options = clone(options);
 
@@ -2063,7 +2067,7 @@ namespace ts {
                 options[opt.name] = parseCustomTypeOption(opt, value, diagnostics);
             }
             else {
-                if (!forEachValue(opt.type, v => v === value)) {
+                if (!forEachProperty(opt.type, v => v === value)) {
                     // Supplied value isn't a valid enum value.
                     diagnostics.push(createCompilerDiagnosticForInvalidCustomType(opt));
                 }
@@ -2122,7 +2126,9 @@ namespace ts {
             sourceFile.moduleName = transpileOptions.moduleName;
         }
 
-        sourceFile.renamedDependencies = transpileOptions.renamedDependencies;
+        if (transpileOptions.renamedDependencies) {
+            sourceFile.renamedDependencies = createMap(transpileOptions.renamedDependencies);
+        }
 
         const newLine = getNewLineCharacter(options);
 
@@ -2248,7 +2254,7 @@ namespace ts {
     export function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory = ""): DocumentRegistry {
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.
-        const buckets: Map<FileMap<DocumentRegistryEntry>> = {};
+        const buckets = createMap<FileMap<DocumentRegistryEntry>>();
         const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
 
         function getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey {
@@ -2256,7 +2262,7 @@ namespace ts {
         }
 
         function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): FileMap<DocumentRegistryEntry> {
-            let bucket = lookUp(buckets, key);
+            let bucket = buckets[key];
             if (!bucket && createIfMissing) {
                 buckets[key] = bucket = createFileMap<DocumentRegistryEntry>();
             }
@@ -2265,7 +2271,7 @@ namespace ts {
 
         function reportStats() {
             const bucketInfoArray = Object.keys(buckets).filter(name => name && name.charAt(0) === "_").map(name => {
-                const entries = lookUp(buckets, name);
+                const entries = buckets[name];
                 const sourceFiles: { name: string; refCount: number; references: string[]; }[] = [];
                 entries.forEachValue((key, entry) => {
                     sourceFiles.push({
@@ -3104,7 +3110,7 @@ namespace ts {
                  oldSettings.allowJs !== newSettings.allowJs ||
                  oldSettings.disableSizeLimit !== oldSettings.disableSizeLimit ||
                  oldSettings.baseUrl !== newSettings.baseUrl ||
-                 !mapIsEqualTo(oldSettings.paths, newSettings.paths));
+                 !equalOwnProperties(oldSettings.paths, newSettings.paths));
 
             // Now create a new compiler
             const compilerHost: CompilerHost = {
@@ -3119,7 +3125,6 @@ namespace ts {
                 getCurrentDirectory: () => currentDirectory,
                 fileExists: (fileName): boolean => {
                     // stub missing host functionality
-                    Debug.assert(!host.resolveModuleNames || !host.resolveTypeReferenceDirectives);
                     return hostCache.getOrCreateEntry(fileName) !== undefined;
                 },
                 readFile: (fileName): string => {
@@ -3793,7 +3798,11 @@ namespace ts {
                     // other than those within the declared type.
                     isNewIdentifierLocation = true;
 
+                    // If the object literal is being assigned to something of type 'null | { hello: string }',
+                    // it clearly isn't trying to satisfy the 'null' type. So we grab the non-nullable type if possible.
                     typeForObject = typeChecker.getContextualType(<ObjectLiteralExpression>objectLikeContainer);
+                    typeForObject = typeForObject && typeForObject.getNonNullableType();
+
                     existingMembers = (<ObjectLiteralExpression>objectLikeContainer).properties;
                 }
                 else if (objectLikeContainer.kind === SyntaxKind.ObjectBindingPattern) {
@@ -3805,7 +3814,7 @@ namespace ts {
                         // We don't want to complete using the type acquired by the shape
                         // of the binding pattern; we are only interested in types acquired
                         // through type declaration or inference.
-                        // Also proceed if rootDeclaration is parameter and if its containing function expression\arrow function is contextually typed -
+                        // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                         // type of parameter will flow in from the contextual type of the function
                         let canGetType = !!(rootDeclaration.initializer || rootDeclaration.type);
                         if (!canGetType && rootDeclaration.kind === SyntaxKind.Parameter) {
@@ -4107,7 +4116,7 @@ namespace ts {
              *          do not occur at the current position and have not otherwise been typed.
              */
             function filterNamedImportOrExportCompletionItems(exportsOfModule: Symbol[], namedImportsOrExports: ImportOrExportSpecifier[]): Symbol[] {
-                const existingImportsOrExports: Map<boolean> = {};
+                const existingImportsOrExports = createMap<boolean>();
 
                 for (const element of namedImportsOrExports) {
                     // If this is the current item we are editing right now, do not filter it out
@@ -4119,11 +4128,11 @@ namespace ts {
                     existingImportsOrExports[name.text] = true;
                 }
 
-                if (isEmpty(existingImportsOrExports)) {
+                if (!someProperties(existingImportsOrExports)) {
                     return filter(exportsOfModule, e => e.name !== "default");
                 }
 
-                return filter(exportsOfModule, e => e.name !== "default" && !lookUp(existingImportsOrExports, e.name));
+                return filter(exportsOfModule, e => e.name !== "default" && !existingImportsOrExports[e.name]);
             }
 
             /**
@@ -4137,7 +4146,7 @@ namespace ts {
                     return contextualMemberSymbols;
                 }
 
-                const existingMemberNames: Map<boolean> = {};
+                const existingMemberNames = createMap<boolean>();
                 for (const m of existingMembers) {
                     // Ignore omitted expressions for missing members
                     if (m.kind !== SyntaxKind.PropertyAssignment &&
@@ -4170,7 +4179,7 @@ namespace ts {
                     existingMemberNames[existingName] = true;
                 }
 
-                return filter(contextualMemberSymbols, m => !lookUp(existingMemberNames, m.name));
+                return filter(contextualMemberSymbols, m => !existingMemberNames[m.name]);
             }
 
             /**
@@ -4180,7 +4189,7 @@ namespace ts {
              *          do not occur at the current position and have not otherwise been typed.
              */
             function filterJsxAttributes(symbols: Symbol[], attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>): Symbol[] {
-                const seenNames: Map<boolean> = {};
+                const seenNames = createMap<boolean>();
                 for (const attr of attributes) {
                     // If this is the current item we are editing right now, do not filter it out
                     if (attr.getStart() <= position && position <= attr.getEnd()) {
@@ -4192,7 +4201,7 @@ namespace ts {
                     }
                 }
 
-                return filter(symbols, a => !lookUp(seenNames, a.name));
+                return filter(symbols, a => !seenNames[a.name]);
             }
         }
 
@@ -4252,7 +4261,7 @@ namespace ts {
                 addRange(entries, keywordCompletions);
             }
 
-            return { isMemberCompletion, isNewIdentifierLocation, entries };
+            return { isMemberCompletion, isNewIdentifierLocation: isNewIdentifierLocation || isSourceFileJavaScript(sourceFile), entries };
 
             function getJavaScriptCompletionEntries(sourceFile: SourceFile, position: number, uniqueNames: Map<string>): CompletionEntry[] {
                 const entries: CompletionEntry[] = [];
@@ -4322,13 +4331,13 @@ namespace ts {
 
             function getCompletionEntriesFromSymbols(symbols: Symbol[], entries: CompletionEntry[], location: Node, performCharacterChecks: boolean): Map<string> {
                 const start = timestamp();
-                const uniqueNames: Map<string> = {};
+                const uniqueNames = createMap<string>();
                 if (symbols) {
                     for (const symbol of symbols) {
                         const entry = createCompletionEntry(symbol, location, performCharacterChecks);
                         if (entry) {
                             const id = escapeIdentifier(entry.name);
-                            if (!lookUp(uniqueNames, id)) {
+                            if (!uniqueNames[id]) {
                                 entries.push(entry);
                                 uniqueNames[id] = id;
                             }
@@ -4917,6 +4926,28 @@ namespace ts {
 
             if (!documentation) {
                 documentation = symbol.getDocumentationComment();
+                if (documentation.length === 0 && symbol.flags & SymbolFlags.Property) {
+                    // For some special property access expressions like `experts.foo = foo` or `module.exports.foo = foo`
+                    // there documentation comments might be attached to the right hand side symbol of their declarations.
+                    // The pattern of such special property access is that the parent symbol is the symbol of the file.
+                    if (symbol.parent && forEach(symbol.parent.declarations, declaration => declaration.kind === SyntaxKind.SourceFile)) {
+                        for (const declaration of symbol.declarations) {
+                            if (!declaration.parent || declaration.parent.kind !== SyntaxKind.BinaryExpression) {
+                                continue;
+                            }
+
+                            const rhsSymbol = program.getTypeChecker().getSymbolAtLocation((<BinaryExpression>declaration.parent).right);
+                            if (!rhsSymbol) {
+                                continue;
+                            }
+
+                            documentation = rhsSymbol.getDocumentationComment();
+                            if (documentation.length > 0) {
+                                break;
+                            }
+                        }
+                    }
+                }
             }
 
             return { displayParts, documentation, symbolKind };
@@ -5156,7 +5187,7 @@ namespace ts {
             // Type reference directives
             const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
             if (typeReferenceDirective) {
-                const referenceFile = lookUp(program.getResolvedTypeReferenceDirectives(), typeReferenceDirective.fileName);
+                const referenceFile = program.getResolvedTypeReferenceDirectives()[typeReferenceDirective.fileName];
                 if (referenceFile && referenceFile.resolvedFileName) {
                     return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
                 }
@@ -5323,12 +5354,12 @@ namespace ts {
                         return undefined;
                     }
 
-                    const fileNameToDocumentHighlights: Map<DocumentHighlights> = {};
+                    const fileNameToDocumentHighlights = createMap<DocumentHighlights>();
                     const result: DocumentHighlights[] = [];
                     for (const referencedSymbol of referencedSymbols) {
                         for (const referenceEntry of referencedSymbol.references) {
                             const fileName = referenceEntry.fileName;
-                            let documentHighlights = getProperty(fileNameToDocumentHighlights, fileName);
+                            let documentHighlights = fileNameToDocumentHighlights[fileName];
                             if (!documentHighlights) {
                                 documentHighlights = { fileName, highlightSpans: [] };
 
@@ -6073,7 +6104,7 @@ namespace ts {
 
                     const nameTable = getNameTable(sourceFile);
 
-                    if (lookUp(nameTable, internedName) !== undefined) {
+                    if (nameTable[internedName] !== undefined) {
                         result = result || [];
                         getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result, symbolToIndex);
                     }
@@ -6718,7 +6749,7 @@ namespace ts {
 
                     // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
                     if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ {});
+                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>());
                     }
                 });
 
@@ -6750,7 +6781,7 @@ namespace ts {
                 // the function will add any found symbol of the property-name, then its sub-routine will call
                 // getPropertySymbolsFromBaseTypes again to walk up any base types to prevent revisiting already
                 // visited symbol, interface "C", the sub-routine will pass the current symbol as previousIterationSymbol.
-                if (hasProperty(previousIterationSymbolsCache, symbol.name)) {
+                if (symbol.name in previousIterationSymbolsCache) {
                     return;
                 }
 
@@ -6839,7 +6870,7 @@ namespace ts {
                     // see if any is in the list
                     if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
                         const result: Symbol[] = [];
-                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ {});
+                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result, /*previousIterationSymbolsCache*/ createMap<Symbol>());
                         return forEach(result, s => searchSymbols.indexOf(s) >= 0 ? s : undefined);
                     }
 
@@ -7574,6 +7605,10 @@ namespace ts {
              * False will mean that node is not classified and traverse routine should recurse into node contents.
              */
             function tryClassifyNode(node: Node): boolean {
+                if (isJSDocTag(node)) {
+                    return true;
+                }
+
                 if (nodeIsMissing(node)) {
                     return true;
                 }
@@ -8323,7 +8358,7 @@ namespace ts {
     }
 
     function initializeNameTable(sourceFile: SourceFile): void {
-        const nameTable: Map<number> = {};
+        const nameTable = createMap<number>();
 
         walk(sourceFile);
         sourceFile.nameTable = nameTable;
diff --git a/src/services/shims.ts b/src/services/shims.ts
index 45c4b284ae744..9a581ed6be18d 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -311,9 +311,9 @@ namespace ts {
             // 'in' does not have this effect.
             if ("getModuleResolutionsForFile" in this.shimHost) {
                 this.resolveModuleNames = (moduleNames: string[], containingFile: string) => {
-                    const resolutionsInFile = <Map<string>>JSON.parse(this.shimHost.getModuleResolutionsForFile(containingFile));
+                    const resolutionsInFile = <MapLike<string>>JSON.parse(this.shimHost.getModuleResolutionsForFile(containingFile));
                     return map(moduleNames, name => {
-                        const result = lookUp(resolutionsInFile, name);
+                        const result = getProperty(resolutionsInFile, name);
                         return result ? { resolvedFileName: result } : undefined;
                     });
                 };
@@ -323,8 +323,8 @@ namespace ts {
             }
             if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) {
                 this.resolveTypeReferenceDirectives = (typeDirectiveNames: string[], containingFile: string) => {
-                    const typeDirectivesForFile = <Map<ResolvedTypeReferenceDirective>>JSON.parse(this.shimHost.getTypeReferenceDirectiveResolutionsForFile(containingFile));
-                    return map(typeDirectiveNames, name => lookUp(typeDirectivesForFile, name));
+                    const typeDirectivesForFile = <MapLike<ResolvedTypeReferenceDirective>>JSON.parse(this.shimHost.getTypeReferenceDirectiveResolutionsForFile(containingFile));
+                    return map(typeDirectiveNames, name => getProperty(typeDirectivesForFile, name));
                 };
             }
         }
@@ -1203,6 +1203,6 @@ namespace TypeScript.Services {
 // TODO: it should be moved into a namespace though.
 
 /* @internal */
-const toolsVersion = "1.9";
+const toolsVersion = "2.1";
 
 /* tslint:enable:no-unused-variable */
diff --git a/src/services/signatureHelp.ts b/src/services/signatureHelp.ts
index 50378aa64b1a1..211e55b23ba5e 100644
--- a/src/services/signatureHelp.ts
+++ b/src/services/signatureHelp.ts
@@ -237,7 +237,7 @@ namespace ts.SignatureHelp {
         const typeChecker = program.getTypeChecker();
         for (const sourceFile of program.getSourceFiles()) {
             const nameToDeclarations = sourceFile.getNamedDeclarations();
-            const declarations = getProperty(nameToDeclarations, name.text);
+            const declarations = nameToDeclarations[name.text];
 
             if (declarations) {
                 for (const declaration of declarations) {
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 215fbefc011a2..740201b8cfbaa 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -925,4 +925,24 @@ namespace ts {
         }
         return ensureScriptKind(fileName, scriptKind);
     }
+
+    export function parseAndReEmitConfigJSONFile(content: string) {
+        const options: TranspileOptions = {
+            fileName: "config.js",
+            compilerOptions: {
+                target: ScriptTarget.ES6
+            },
+            reportDiagnostics: true
+        };
+        const { outputText, diagnostics } = ts.transpileModule("(" + content + ")", options);
+        // Becasue the content was wrapped in "()", the start position of diagnostics needs to be subtract by 1
+        // also, the emitted result will have "(" in the beginning and ");" in the end. We need to strip these
+        // as well
+        const trimmedOutput = outputText.trim();
+        const configJsonObject = JSON.parse(trimmedOutput.substring(1, trimmedOutput.length - 2));
+        for (const diagnostic of diagnostics) {
+            diagnostic.start = diagnostic.start - 1;
+        }
+        return { configJsonObject, diagnostics };
+    }
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/APISample_watcher.js b/tests/baselines/reference/APISample_watcher.js
index 7573f2ba99ea8..cb7fc3a4c5c92 100644
--- a/tests/baselines/reference/APISample_watcher.js
+++ b/tests/baselines/reference/APISample_watcher.js
@@ -20,7 +20,7 @@ declare var path: any;
 import * as ts from "typescript";
 
 function watch(rootFileNames: string[], options: ts.CompilerOptions) {
-    const files: ts.Map<{ version: number }> = {};
+    const files: ts.MapLike<{ version: number }> = {};
 
     // initialize the list of files
     rootFileNames.forEach(fileName => {
diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword2.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword2.json
index 9197232584782..4148937b278f5 100644
--- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword2.json
+++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword2.json
@@ -1,12 +1,5 @@
 {
-    "kind": "JSDocTypeReference",
+    "kind": "NullKeyword",
     "pos": 1,
-    "end": 5,
-    "name": {
-        "kind": "Identifier",
-        "pos": 1,
-        "end": 5,
-        "originalKeywordKind": "NullKeyword",
-        "text": "null"
-    }
+    "end": 5
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword3.json b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword3.json
index 408fb1c6f469d..c61912f9eb83b 100644
--- a/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword3.json
+++ b/tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword3.json
@@ -1,12 +1,5 @@
 {
-    "kind": "JSDocTypeReference",
+    "kind": "UndefinedKeyword",
     "pos": 1,
-    "end": 10,
-    "name": {
-        "kind": "Identifier",
-        "pos": 1,
-        "end": 10,
-        "originalKeywordKind": "UndefinedKeyword",
-        "text": "undefined"
-    }
+    "end": 10
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/ambientShorthand_isImplicitAny.errors.txt b/tests/baselines/reference/ambientShorthand_isImplicitAny.errors.txt
deleted file mode 100644
index 875a656202d11..0000000000000
--- a/tests/baselines/reference/ambientShorthand_isImplicitAny.errors.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts(1,16): error TS7005: Variable '"jquery"' implicitly has an 'any' type.
-
-
-==== tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts (1 errors) ====
-    declare module "jquery";
-                   ~~~~~~~~
-!!! error TS7005: Variable '"jquery"' implicitly has an 'any' type.
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/ambientShorthand_isImplicitAny.js b/tests/baselines/reference/ambientShorthand_isImplicitAny.js
deleted file mode 100644
index ab05d2a9979c1..0000000000000
--- a/tests/baselines/reference/ambientShorthand_isImplicitAny.js
+++ /dev/null
@@ -1,5 +0,0 @@
-//// [ambientShorthand_isImplicitAny.ts]
-declare module "jquery";
-
-
-//// [ambientShorthand_isImplicitAny.js]
diff --git a/tests/baselines/reference/apparentTypeSubtyping.errors.txt b/tests/baselines/reference/apparentTypeSubtyping.errors.txt
index e1a53ef6a73cc..01fffeb382494 100644
--- a/tests/baselines/reference/apparentTypeSubtyping.errors.txt
+++ b/tests/baselines/reference/apparentTypeSubtyping.errors.txt
@@ -1,6 +1,7 @@
 tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtyping.ts(9,7): error TS2415: Class 'Derived<U>' incorrectly extends base class 'Base<string>'.
   Types of property 'x' are incompatible.
     Type 'String' is not assignable to type 'string'.
+      'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 
 
 ==== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtyping.ts (1 errors) ====
@@ -17,6 +18,7 @@ tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtypi
 !!! error TS2415: Class 'Derived<U>' incorrectly extends base class 'Base<string>'.
 !!! error TS2415:   Types of property 'x' are incompatible.
 !!! error TS2415:     Type 'String' is not assignable to type 'string'.
+!!! error TS2415:       'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
         x: String;
     }
     
diff --git a/tests/baselines/reference/apparentTypeSupertype.errors.txt b/tests/baselines/reference/apparentTypeSupertype.errors.txt
index 5fe5c92a5b3e8..c7610a80f2f37 100644
--- a/tests/baselines/reference/apparentTypeSupertype.errors.txt
+++ b/tests/baselines/reference/apparentTypeSupertype.errors.txt
@@ -2,6 +2,7 @@ tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSuperty
   Types of property 'x' are incompatible.
     Type 'U' is not assignable to type 'string'.
       Type 'String' is not assignable to type 'string'.
+        'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 
 
 ==== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSupertype.ts (1 errors) ====
@@ -19,5 +20,6 @@ tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSuperty
 !!! error TS2415:   Types of property 'x' are incompatible.
 !!! error TS2415:     Type 'U' is not assignable to type 'string'.
 !!! error TS2415:       Type 'String' is not assignable to type 'string'.
+!!! error TS2415:         'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
         x: U;
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
index d60f0b7d03c47..a6a685069d6b0 100644
--- a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
+++ b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
@@ -39,8 +39,7 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(26,5): error
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(27,5): error TS2322: Type '{ 0: string; 1: number; }' is not assignable to type '[string]'.
   Property 'length' is missing in type '{ 0: string; 1: number; }'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(28,5): error TS2322: Type '[string, number]' is not assignable to type '[number, string]'.
-  Types of property '0' are incompatible.
-    Type 'string' is not assignable to type 'number'.
+  Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(29,5): error TS2322: Type 'StrNum' is not assignable to type '[number, string]'.
   Types of property '0' are incompatible.
     Type 'string' is not assignable to type 'number'.
@@ -136,8 +135,7 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(30,5): error
     var n1: [number, string] = x;
         ~~
 !!! error TS2322: Type '[string, number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'string' is not assignable to type 'number'.
+!!! error TS2322:   Type 'string' is not assignable to type 'number'.
     var n2: [number, string] = y;
         ~~
 !!! error TS2322: Type 'StrNum' is not assignable to type '[number, string]'.
diff --git a/tests/baselines/reference/arrayLiterals3.errors.txt b/tests/baselines/reference/arrayLiterals3.errors.txt
index 8e6c7eccf81f8..1f0dd30c09ce6 100644
--- a/tests/baselines/reference/arrayLiterals3.errors.txt
+++ b/tests/baselines/reference/arrayLiterals3.errors.txt
@@ -1,8 +1,7 @@
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(10,5): error TS2322: Type 'undefined[]' is not assignable to type '[any, any, any]'.
   Property '0' is missing in type 'undefined[]'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(11,5): error TS2322: Type '[string, number, boolean]' is not assignable to type '[boolean, string, number]'.
-  Types of property '0' are incompatible.
-    Type 'string' is not assignable to type 'boolean'.
+  Type 'string' is not assignable to type 'boolean'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(17,5): error TS2322: Type '[number, number, string, boolean]' is not assignable to type '[number, number]'.
   Types of property 'pop' are incompatible.
     Type '() => string | number | boolean' is not assignable to type '() => number'.
@@ -18,6 +17,7 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
       Types of parameters 'items' and 'items' are incompatible.
         Type 'Number' is not assignable to type 'string | number'.
           Type 'Number' is not assignable to type 'number'.
+            'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 
 
 ==== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts (6 errors) ====
@@ -37,8 +37,7 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
     var a1: [boolean, string, number] = ["string", 1, true];  // Error
         ~~
 !!! error TS2322: Type '[string, number, boolean]' is not assignable to type '[boolean, string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'string' is not assignable to type 'boolean'.
+!!! error TS2322:   Type 'string' is not assignable to type 'boolean'.
     
     // The resulting type an array literal expression is determined as follows:
     //     - If the array literal contains no spread elements and is an array assignment pattern in a destructuring assignment (section 4.17.1),
@@ -81,4 +80,5 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
 !!! error TS2322:       Types of parameters 'items' and 'items' are incompatible.
 !!! error TS2322:         Type 'Number' is not assignable to type 'string | number'.
 !!! error TS2322:           Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:             'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
new file mode 100644
index 0000000000000..6f4a0ef9d6df7
--- /dev/null
+++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt
@@ -0,0 +1,46 @@
+tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
+  Types of property 'concat' are incompatible.
+    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+      Type 'A[]' is not assignable to type 'B[]'.
+        Type 'A' is not assignable to type 'B'.
+          Property 'b' is missing in type 'A'.
+tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
+  Types of property 'concat' are incompatible.
+    Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+      Type 'A[]' is not assignable to type 'B[]'.
+        Type 'A' is not assignable to type 'B'.
+
+
+==== tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts (2 errors) ====
+    class A { a }
+    class B extends A { b }
+    class C<T> extends Array<T> { c }
+    declare var ara: A[];
+    declare var arb: B[];
+    declare var cra: C<A>;
+    declare var crb: C<B>;
+    declare var rra: ReadonlyArray<A>;
+    declare var rrb: ReadonlyArray<B>;
+    rra = ara;
+    rrb = arb; // OK, Array<B> is assignable to ReadonlyArray<A>
+    rra = arb;
+    rrb = ara; // error: 'A' is not assignable to 'B'
+    ~~~
+!!! error TS2322: Type 'A[]' is not assignable to type 'ReadonlyArray<B>'.
+!!! error TS2322:   Types of property 'concat' are incompatible.
+!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+!!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
+!!! error TS2322:         Type 'A' is not assignable to type 'B'.
+!!! error TS2322:           Property 'b' is missing in type 'A'.
+    
+    rra = cra;
+    rra = crb; // OK, C<B> is assignable to ReadonlyArray<A>
+    rrb = crb;
+    rrb = cra; // error: 'A' is not assignable to 'B'
+    ~~~
+!!! error TS2322: Type 'C<A>' is not assignable to type 'ReadonlyArray<B>'.
+!!! error TS2322:   Types of property 'concat' are incompatible.
+!!! error TS2322:     Type '{ (...items: A[][]): A[]; (...items: (A | A[])[]): A[]; }' is not assignable to type '{ <U extends ReadonlyArray<B>>(...items: U[]): B[]; (...items: B[][]): B[]; (...items: (B | B[])[]): B[]; }'.
+!!! error TS2322:       Type 'A[]' is not assignable to type 'B[]'.
+!!! error TS2322:         Type 'A' is not assignable to type 'B'.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.js b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.js
new file mode 100644
index 0000000000000..255b52e16c989
--- /dev/null
+++ b/tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.js
@@ -0,0 +1,54 @@
+//// [arrayOfSubtypeIsAssignableToReadonlyArray.ts]
+class A { a }
+class B extends A { b }
+class C<T> extends Array<T> { c }
+declare var ara: A[];
+declare var arb: B[];
+declare var cra: C<A>;
+declare var crb: C<B>;
+declare var rra: ReadonlyArray<A>;
+declare var rrb: ReadonlyArray<B>;
+rra = ara;
+rrb = arb; // OK, Array<B> is assignable to ReadonlyArray<A>
+rra = arb;
+rrb = ara; // error: 'A' is not assignable to 'B'
+
+rra = cra;
+rra = crb; // OK, C<B> is assignable to ReadonlyArray<A>
+rrb = crb;
+rrb = cra; // error: 'A' is not assignable to 'B'
+
+
+//// [arrayOfSubtypeIsAssignableToReadonlyArray.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var A = (function () {
+    function A() {
+    }
+    return A;
+}());
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.apply(this, arguments);
+    }
+    return B;
+}(A));
+var C = (function (_super) {
+    __extends(C, _super);
+    function C() {
+        _super.apply(this, arguments);
+    }
+    return C;
+}(Array));
+rra = ara;
+rrb = arb; // OK, Array<B> is assignable to ReadonlyArray<A>
+rra = arb;
+rrb = ara; // error: 'A' is not assignable to 'B'
+rra = cra;
+rra = crb; // OK, C<B> is assignable to ReadonlyArray<A>
+rrb = crb;
+rrb = cra; // error: 'A' is not assignable to 'B'
diff --git a/tests/baselines/reference/assignFromBooleanInterface.errors.txt b/tests/baselines/reference/assignFromBooleanInterface.errors.txt
index 4b06603a9bf02..555b645cd7dc1 100644
--- a/tests/baselines/reference/assignFromBooleanInterface.errors.txt
+++ b/tests/baselines/reference/assignFromBooleanInterface.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts(3,1): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+  'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
 
 
 ==== tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts (1 errors) ====
@@ -7,4 +8,5 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts(3
     x = a;
     ~
 !!! error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+!!! error TS2322:   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
     a = x;
\ No newline at end of file
diff --git a/tests/baselines/reference/assignFromBooleanInterface2.errors.txt b/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
index c03eab60c7477..6c7ebbe5ee83f 100644
--- a/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromBooleanInterface2.errors.txt
@@ -3,6 +3,7 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(
     Type '() => Object' is not assignable to type '() => boolean'.
       Type 'Object' is not assignable to type 'boolean'.
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(19,1): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+  'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(20,1): error TS2322: Type 'NotBoolean' is not assignable to type 'boolean'.
 
 
@@ -33,6 +34,7 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(
     x = a; // expected error
     ~
 !!! error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+!!! error TS2322:   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
     x = b; // expected error
     ~
 !!! error TS2322: Type 'NotBoolean' is not assignable to type 'boolean'.
diff --git a/tests/baselines/reference/assignFromNumberInterface.errors.txt b/tests/baselines/reference/assignFromNumberInterface.errors.txt
index 0c8c4a5f5aca0..1a70ef342d2b8 100644
--- a/tests/baselines/reference/assignFromNumberInterface.errors.txt
+++ b/tests/baselines/reference/assignFromNumberInterface.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts(3,1): error TS2322: Type 'Number' is not assignable to type 'number'.
+  'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 
 
 ==== tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts (1 errors) ====
@@ -7,4 +8,5 @@ tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts(3,1
     x = a;
     ~
 !!! error TS2322: Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:   'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     a = x;
\ No newline at end of file
diff --git a/tests/baselines/reference/assignFromNumberInterface2.errors.txt b/tests/baselines/reference/assignFromNumberInterface2.errors.txt
index 85639cdeeaf18..3297501d61208 100644
--- a/tests/baselines/reference/assignFromNumberInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromNumberInterface2.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts(24,1): error TS2322: Type 'Number' is not assignable to type 'number'.
+  'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts(25,1): error TS2322: Type 'NotNumber' is not assignable to type 'number'.
 
 
@@ -29,6 +30,7 @@ tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts(25
     x = a; // expected error
     ~
 !!! error TS2322: Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:   'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     x = b; // expected error
     ~
 !!! error TS2322: Type 'NotNumber' is not assignable to type 'number'.
diff --git a/tests/baselines/reference/assignFromStringInterface.errors.txt b/tests/baselines/reference/assignFromStringInterface.errors.txt
index 6ec8afad12072..7e7af4d1b9daf 100644
--- a/tests/baselines/reference/assignFromStringInterface.errors.txt
+++ b/tests/baselines/reference/assignFromStringInterface.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts(3,1): error TS2322: Type 'String' is not assignable to type 'string'.
+  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 
 
 ==== tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts (1 errors) ====
@@ -7,4 +8,5 @@ tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts(3,1
     x = a;
     ~
 !!! error TS2322: Type 'String' is not assignable to type 'string'.
+!!! error TS2322:   'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
     a = x;
\ No newline at end of file
diff --git a/tests/baselines/reference/assignFromStringInterface2.errors.txt b/tests/baselines/reference/assignFromStringInterface2.errors.txt
index 4e09eb6eacbf6..0fc3284bf0046 100644
--- a/tests/baselines/reference/assignFromStringInterface2.errors.txt
+++ b/tests/baselines/reference/assignFromStringInterface2.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts(47,1): error TS2322: Type 'String' is not assignable to type 'string'.
+  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts(48,1): error TS2322: Type 'NotString' is not assignable to type 'string'.
 
 
@@ -52,6 +53,7 @@ tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts(48
     x = a; // expected error
     ~
 !!! error TS2322: Type 'String' is not assignable to type 'string'.
+!!! error TS2322:   'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
     x = b; // expected error
     ~
 !!! error TS2322: Type 'NotString' is not assignable to type 'string'.
diff --git a/tests/baselines/reference/await_unaryExpression_es6.js b/tests/baselines/reference/await_unaryExpression_es6.js
new file mode 100644
index 0000000000000..46065bdada925
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6.js
@@ -0,0 +1,47 @@
+//// [await_unaryExpression_es6.ts]
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    +await 42; // OK
+}
+
+async function bar3() {
+    -await 42; // OK
+}
+
+async function bar4() {
+    ~await 42; // OK
+}
+
+//// [await_unaryExpression_es6.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar() {
+    return __awaiter(this, void 0, void 0, function* () {
+        !(yield 42); // OK
+    });
+}
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        +(yield 42); // OK
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        -(yield 42); // OK
+    });
+}
+function bar4() {
+    return __awaiter(this, void 0, void 0, function* () {
+        ~(yield 42); // OK
+    });
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6.symbols b/tests/baselines/reference/await_unaryExpression_es6.symbols
new file mode 100644
index 0000000000000..81edd4b981b1b
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6.symbols
@@ -0,0 +1,25 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6.ts ===
+
+async function bar() {
+>bar : Symbol(bar, Decl(await_unaryExpression_es6.ts, 0, 0))
+
+    !await 42; // OK
+}
+
+async function bar1() {
+>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6.ts, 3, 1))
+
+    +await 42; // OK
+}
+
+async function bar3() {
+>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6.ts, 7, 1))
+
+    -await 42; // OK
+}
+
+async function bar4() {
+>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6.ts, 11, 1))
+
+    ~await 42; // OK
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6.types b/tests/baselines/reference/await_unaryExpression_es6.types
new file mode 100644
index 0000000000000..2a4b7354d3ebf
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6.types
@@ -0,0 +1,37 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6.ts ===
+
+async function bar() {
+>bar : () => Promise<void>
+
+    !await 42; // OK
+>!await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar1() {
+>bar1 : () => Promise<void>
+
+    +await 42; // OK
+>+await 42 : number
+>await 42 : number
+>42 : number
+}
+
+async function bar3() {
+>bar3 : () => Promise<void>
+
+    -await 42; // OK
+>-await 42 : number
+>await 42 : number
+>42 : number
+}
+
+async function bar4() {
+>bar4 : () => Promise<void>
+
+    ~await 42; // OK
+>~await 42 : number
+>await 42 : number
+>42 : number
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.js b/tests/baselines/reference/await_unaryExpression_es6_1.js
new file mode 100644
index 0000000000000..c6f5f1142c085
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_1.js
@@ -0,0 +1,56 @@
+//// [await_unaryExpression_es6_1.ts]
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    delete await 42; // OK
+}
+
+async function bar2() {
+    delete await 42; // OK
+}
+
+async function bar3() {
+    void await 42;
+}
+
+async function bar4() {
+    +await 42;
+}
+
+//// [await_unaryExpression_es6_1.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar() {
+    return __awaiter(this, void 0, void 0, function* () {
+        !(yield 42); // OK
+    });
+}
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42); // OK
+    });
+}
+function bar2() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42); // OK
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        void (yield 42);
+    });
+}
+function bar4() {
+    return __awaiter(this, void 0, void 0, function* () {
+        +(yield 42);
+    });
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.symbols b/tests/baselines/reference/await_unaryExpression_es6_1.symbols
new file mode 100644
index 0000000000000..ed7d7e4ed02e9
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_1.symbols
@@ -0,0 +1,31 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts ===
+
+async function bar() {
+>bar : Symbol(bar, Decl(await_unaryExpression_es6_1.ts, 0, 0))
+
+    !await 42; // OK
+}
+
+async function bar1() {
+>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_1.ts, 3, 1))
+
+    delete await 42; // OK
+}
+
+async function bar2() {
+>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_1.ts, 7, 1))
+
+    delete await 42; // OK
+}
+
+async function bar3() {
+>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_1.ts, 11, 1))
+
+    void await 42;
+}
+
+async function bar4() {
+>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6_1.ts, 15, 1))
+
+    +await 42;
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.types b/tests/baselines/reference/await_unaryExpression_es6_1.types
new file mode 100644
index 0000000000000..a5c3740b677f1
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_1.types
@@ -0,0 +1,46 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts ===
+
+async function bar() {
+>bar : () => Promise<void>
+
+    !await 42; // OK
+>!await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar1() {
+>bar1 : () => Promise<void>
+
+    delete await 42; // OK
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar2() {
+>bar2 : () => Promise<void>
+
+    delete await 42; // OK
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar3() {
+>bar3 : () => Promise<void>
+
+    void await 42;
+>void await 42 : undefined
+>await 42 : number
+>42 : number
+}
+
+async function bar4() {
+>bar4 : () => Promise<void>
+
+    +await 42;
+>+await 42 : number
+>await 42 : number
+>42 : number
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.js b/tests/baselines/reference/await_unaryExpression_es6_2.js
new file mode 100644
index 0000000000000..3c341018ed16c
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_2.js
@@ -0,0 +1,38 @@
+//// [await_unaryExpression_es6_2.ts]
+
+async function bar1() {
+    delete await 42;
+}
+
+async function bar2() {
+    delete await 42;
+}
+
+async function bar3() {
+    void await 42;
+}
+
+//// [await_unaryExpression_es6_2.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42);
+    });
+}
+function bar2() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42);
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        void (yield 42);
+    });
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.symbols b/tests/baselines/reference/await_unaryExpression_es6_2.symbols
new file mode 100644
index 0000000000000..574ea4d433a7a
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_2.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts ===
+
+async function bar1() {
+>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_2.ts, 0, 0))
+
+    delete await 42;
+}
+
+async function bar2() {
+>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_2.ts, 3, 1))
+
+    delete await 42;
+}
+
+async function bar3() {
+>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_2.ts, 7, 1))
+
+    void await 42;
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.types b/tests/baselines/reference/await_unaryExpression_es6_2.types
new file mode 100644
index 0000000000000..b438f063add31
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_2.types
@@ -0,0 +1,28 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts ===
+
+async function bar1() {
+>bar1 : () => Promise<void>
+
+    delete await 42;
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar2() {
+>bar2 : () => Promise<void>
+
+    delete await 42;
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar3() {
+>bar3 : () => Promise<void>
+
+    void await 42;
+>void await 42 : undefined
+>await 42 : number
+>42 : number
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt
new file mode 100644
index 0000000000000..5518f84983f78
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt
@@ -0,0 +1,27 @@
+tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(3,7): error TS1109: Expression expected.
+tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(7,7): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts (2 errors) ====
+    
+    async function bar1() {
+        ++await 42; // Error
+          ~~~~~
+!!! error TS1109: Expression expected.
+    }
+    
+    async function bar2() {
+        --await 42; // Error
+          ~~~~~
+!!! error TS1109: Expression expected.
+    }
+    
+    async function bar3() {
+        var x = 42;
+        await x++; // OK but shouldn't need parenthesis
+    }
+    
+    async function bar4() {
+        var x = 42;
+        await x--; // OK but shouldn't need parenthesis
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.js b/tests/baselines/reference/await_unaryExpression_es6_3.js
new file mode 100644
index 0000000000000..077e264c450e4
--- /dev/null
+++ b/tests/baselines/reference/await_unaryExpression_es6_3.js
@@ -0,0 +1,53 @@
+//// [await_unaryExpression_es6_3.ts]
+
+async function bar1() {
+    ++await 42; // Error
+}
+
+async function bar2() {
+    --await 42; // Error
+}
+
+async function bar3() {
+    var x = 42;
+    await x++; // OK but shouldn't need parenthesis
+}
+
+async function bar4() {
+    var x = 42;
+    await x--; // OK but shouldn't need parenthesis
+}
+
+//// [await_unaryExpression_es6_3.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        ++;
+        yield 42; // Error
+    });
+}
+function bar2() {
+    return __awaiter(this, void 0, void 0, function* () {
+        --;
+        yield 42; // Error
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var x = 42;
+        yield x++; // OK but shouldn't need parenthesis
+    });
+}
+function bar4() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var x = 42;
+        yield x--; // OK but shouldn't need parenthesis
+    });
+}
diff --git a/tests/baselines/reference/castOfAwait.js b/tests/baselines/reference/castOfAwait.js
new file mode 100644
index 0000000000000..26e9812bf431e
--- /dev/null
+++ b/tests/baselines/reference/castOfAwait.js
@@ -0,0 +1,28 @@
+//// [castOfAwait.ts]
+async function f() {
+    <number> await 0;
+    typeof await 0;
+    void await 0;
+    await void <string> typeof <number> void await 0;
+    await await 0;
+}
+
+
+//// [castOfAwait.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function f() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 0;
+        typeof (yield 0);
+        void (yield 0);
+        yield void typeof void (yield 0);
+        yield yield 0;
+    });
+}
diff --git a/tests/baselines/reference/castOfAwait.symbols b/tests/baselines/reference/castOfAwait.symbols
new file mode 100644
index 0000000000000..574ee21f7731b
--- /dev/null
+++ b/tests/baselines/reference/castOfAwait.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/compiler/castOfAwait.ts ===
+async function f() {
+>f : Symbol(f, Decl(castOfAwait.ts, 0, 0))
+
+    <number> await 0;
+    typeof await 0;
+    void await 0;
+    await void <string> typeof <number> void await 0;
+    await await 0;
+}
+
diff --git a/tests/baselines/reference/castOfAwait.types b/tests/baselines/reference/castOfAwait.types
new file mode 100644
index 0000000000000..ad3597f6c018a
--- /dev/null
+++ b/tests/baselines/reference/castOfAwait.types
@@ -0,0 +1,35 @@
+=== tests/cases/compiler/castOfAwait.ts ===
+async function f() {
+>f : () => Promise<void>
+
+    <number> await 0;
+><number> await 0 : number
+>await 0 : number
+>0 : number
+
+    typeof await 0;
+>typeof await 0 : string
+>await 0 : number
+>0 : number
+
+    void await 0;
+>void await 0 : undefined
+>await 0 : number
+>0 : number
+
+    await void <string> typeof <number> void await 0;
+>await void <string> typeof <number> void await 0 : any
+>void <string> typeof <number> void await 0 : undefined
+><string> typeof <number> void await 0 : string
+>typeof <number> void await 0 : string
+><number> void await 0 : number
+>void await 0 : undefined
+>await 0 : number
+>0 : number
+
+    await await 0;
+>await await 0 : number
+>await 0 : number
+>0 : number
+}
+
diff --git a/tests/baselines/reference/castOfYield.errors.txt b/tests/baselines/reference/castOfYield.errors.txt
new file mode 100644
index 0000000000000..abafe67878430
--- /dev/null
+++ b/tests/baselines/reference/castOfYield.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/castOfYield.ts(4,14): error TS1109: Expression expected.
+
+
+==== tests/cases/compiler/castOfYield.ts (1 errors) ====
+    function* f() {
+        <number> (yield 0);
+        // Unlike await, yield is not allowed to appear in a simple unary expression.
+        <number> yield 0;
+                 ~~~~~
+!!! error TS1109: Expression expected.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/castOfYield.js b/tests/baselines/reference/castOfYield.js
new file mode 100644
index 0000000000000..633f780a6a144
--- /dev/null
+++ b/tests/baselines/reference/castOfYield.js
@@ -0,0 +1,15 @@
+//// [castOfYield.ts]
+function* f() {
+    <number> (yield 0);
+    // Unlike await, yield is not allowed to appear in a simple unary expression.
+    <number> yield 0;
+}
+
+
+//// [castOfYield.js]
+function* f() {
+    (yield 0);
+    // Unlike await, yield is not allowed to appear in a simple unary expression.
+    ;
+    yield 0;
+}
diff --git a/tests/baselines/reference/castingTuple.errors.txt b/tests/baselines/reference/castingTuple.errors.txt
index 6d5549c6bf2ae..2f9eeedf9efd5 100644
--- a/tests/baselines/reference/castingTuple.errors.txt
+++ b/tests/baselines/reference/castingTuple.errors.txt
@@ -1,10 +1,8 @@
 tests/cases/conformance/types/tuple/castingTuple.ts(28,10): error TS2352: Type '[number, string]' cannot be converted to type '[number, number]'.
-  Types of property '1' are incompatible.
-    Type 'string' is not comparable to type 'number'.
+  Type 'string' is not comparable to type 'number'.
 tests/cases/conformance/types/tuple/castingTuple.ts(29,10): error TS2352: Type '[C, D]' cannot be converted to type '[A, I]'.
-  Types of property '0' are incompatible.
-    Type 'C' is not comparable to type 'A'.
-      Property 'a' is missing in type 'C'.
+  Type 'C' is not comparable to type 'A'.
+    Property 'a' is missing in type 'C'.
 tests/cases/conformance/types/tuple/castingTuple.ts(30,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'array1' must be of type '{}[]', but here has type 'number[]'.
 tests/cases/conformance/types/tuple/castingTuple.ts(31,1): error TS2304: Cannot find name 't4'.
 
@@ -40,14 +38,12 @@ tests/cases/conformance/types/tuple/castingTuple.ts(31,1): error TS2304: Cannot
     var t3 = <[number, number]>numStrTuple;
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2352: Type '[number, string]' cannot be converted to type '[number, number]'.
-!!! error TS2352:   Types of property '1' are incompatible.
-!!! error TS2352:     Type 'string' is not comparable to type 'number'.
+!!! error TS2352:   Type 'string' is not comparable to type 'number'.
     var t9 = <[A, I]>classCDTuple;
              ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2352: Type '[C, D]' cannot be converted to type '[A, I]'.
-!!! error TS2352:   Types of property '0' are incompatible.
-!!! error TS2352:     Type 'C' is not comparable to type 'A'.
-!!! error TS2352:       Property 'a' is missing in type 'C'.
+!!! error TS2352:   Type 'C' is not comparable to type 'A'.
+!!! error TS2352:     Property 'a' is missing in type 'C'.
     var array1 = <number[]>numStrTuple;
         ~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'array1' must be of type '{}[]', but here has type 'number[]'.
diff --git a/tests/baselines/reference/contextualTypeWithTuple.errors.txt b/tests/baselines/reference/contextualTypeWithTuple.errors.txt
index e0580ca237961..a488d8c764829 100644
--- a/tests/baselines/reference/contextualTypeWithTuple.errors.txt
+++ b/tests/baselines/reference/contextualTypeWithTuple.errors.txt
@@ -5,9 +5,8 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(3,5): error TS232
         Type 'true' is not assignable to type 'string | number'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(15,1): error TS2322: Type '[number, string, boolean]' is not assignable to type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(18,1): error TS2322: Type '[{}, number]' is not assignable to type '[{ a: string; }, number]'.
-  Types of property '0' are incompatible.
-    Type '{}' is not assignable to type '{ a: string; }'.
-      Property 'a' is missing in type '{}'.
+  Type '{}' is not assignable to type '{ a: string; }'.
+    Property 'a' is missing in type '{}'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(19,1): error TS2322: Type '[number, string]' is not assignable to type '[number, string, boolean]'.
   Property '2' is missing in type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(20,5): error TS2322: Type '[string, string, number]' is not assignable to type '[string, string]'.
@@ -18,9 +17,8 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(20,5): error TS23
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(24,1): error TS2322: Type '[C, string | number]' is not assignable to type '[C, string | number, D]'.
   Property '2' is missing in type '[C, string | number]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS2322: Type '[number, string | number]' is not assignable to type '[number, string]'.
-  Types of property '1' are incompatible.
-    Type 'string | number' is not assignable to type 'string'.
-      Type 'number' is not assignable to type 'string'.
+  Type 'string | number' is not assignable to type 'string'.
+    Type 'number' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts (7 errors) ====
@@ -52,9 +50,8 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS23
     objNumTuple = [ {}, 5];
     ~~~~~~~~~~~
 !!! error TS2322: Type '[{}, number]' is not assignable to type '[{ a: string; }, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type '{}' is not assignable to type '{ a: string; }'.
-!!! error TS2322:       Property 'a' is missing in type '{}'.
+!!! error TS2322:   Type '{}' is not assignable to type '{ a: string; }'.
+!!! error TS2322:     Property 'a' is missing in type '{}'.
     numStrBoolTuple = numStrTuple;
     ~~~~~~~~~~~~~~~
 !!! error TS2322: Type '[number, string]' is not assignable to type '[number, string, boolean]'.
@@ -76,6 +73,5 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS23
     numStrTuple = unionTuple3;
     ~~~~~~~~~~~
 !!! error TS2322: Type '[number, string | number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type 'string | number' is not assignable to type 'string'.
-!!! error TS2322:       Type 'number' is not assignable to type 'string'.
\ No newline at end of file
+!!! error TS2322:   Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt b/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt
index 42d617887e015..447ccec5ddf91 100644
--- a/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt
+++ b/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt
@@ -11,8 +11,7 @@ tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTyp
 tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(16,23): error TS2322: Type '(arg: string) => number' is not assignable to type '(s: string) => string'.
   Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(21,14): error TS2322: Type '[number, number]' is not assignable to type '[string, number]'.
-  Types of property '0' are incompatible.
-    Type 'number' is not assignable to type 'string'.
+  Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(26,14): error TS2322: Type '"baz"' is not assignable to type '"foo" | "bar"'.
 
 
@@ -57,8 +56,7 @@ tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTyp
     function g({ prop = [101, 1234] }: Tuples) {}
                  ~~~~
 !!! error TS2322: Type '[number, number]' is not assignable to type '[string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
     
     interface StringUnion {
         prop: "foo" | "bar";
diff --git a/tests/baselines/reference/controlFlowBinaryOrExpression.symbols b/tests/baselines/reference/controlFlowBinaryOrExpression.symbols
index e76cfbf4caba9..217e11dc95d0a 100644
--- a/tests/baselines/reference/controlFlowBinaryOrExpression.symbols
+++ b/tests/baselines/reference/controlFlowBinaryOrExpression.symbols
@@ -64,9 +64,9 @@ if (isNodeList(sourceObj)) {
 >sourceObj : Symbol(sourceObj, Decl(controlFlowBinaryOrExpression.ts, 23, 3))
 
     sourceObj.length;
->sourceObj.length : Symbol(length, Decl(controlFlowBinaryOrExpression.ts, 10, 27), Decl(controlFlowBinaryOrExpression.ts, 14, 33))
+>sourceObj.length : Symbol(NodeList.length, Decl(controlFlowBinaryOrExpression.ts, 10, 27))
 >sourceObj : Symbol(sourceObj, Decl(controlFlowBinaryOrExpression.ts, 23, 3))
->length : Symbol(length, Decl(controlFlowBinaryOrExpression.ts, 10, 27), Decl(controlFlowBinaryOrExpression.ts, 14, 33))
+>length : Symbol(NodeList.length, Decl(controlFlowBinaryOrExpression.ts, 10, 27))
 }
 
 if (isHTMLCollection(sourceObj)) {
@@ -74,9 +74,9 @@ if (isHTMLCollection(sourceObj)) {
 >sourceObj : Symbol(sourceObj, Decl(controlFlowBinaryOrExpression.ts, 23, 3))
 
     sourceObj.length;
->sourceObj.length : Symbol(length, Decl(controlFlowBinaryOrExpression.ts, 10, 27), Decl(controlFlowBinaryOrExpression.ts, 14, 33))
+>sourceObj.length : Symbol(HTMLCollection.length, Decl(controlFlowBinaryOrExpression.ts, 14, 33))
 >sourceObj : Symbol(sourceObj, Decl(controlFlowBinaryOrExpression.ts, 23, 3))
->length : Symbol(length, Decl(controlFlowBinaryOrExpression.ts, 10, 27), Decl(controlFlowBinaryOrExpression.ts, 14, 33))
+>length : Symbol(HTMLCollection.length, Decl(controlFlowBinaryOrExpression.ts, 14, 33))
 }
 
 if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {
diff --git a/tests/baselines/reference/controlFlowBinaryOrExpression.types b/tests/baselines/reference/controlFlowBinaryOrExpression.types
index 0bf5ab524b906..7e92fcdbbd153 100644
--- a/tests/baselines/reference/controlFlowBinaryOrExpression.types
+++ b/tests/baselines/reference/controlFlowBinaryOrExpression.types
@@ -80,7 +80,7 @@ if (isNodeList(sourceObj)) {
 
     sourceObj.length;
 >sourceObj.length : number
->sourceObj : NodeList | HTMLCollection
+>sourceObj : NodeList
 >length : number
 }
 
@@ -91,7 +91,7 @@ if (isHTMLCollection(sourceObj)) {
 
     sourceObj.length;
 >sourceObj.length : number
->sourceObj : NodeList | HTMLCollection
+>sourceObj : HTMLCollection
 >length : number
 }
 
@@ -102,11 +102,11 @@ if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {
 >sourceObj : EventTargetLike
 >isHTMLCollection(sourceObj) : boolean
 >isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
->sourceObj : { a: string; }
+>sourceObj : HTMLCollection | { a: string; }
 
     sourceObj.length;
 >sourceObj.length : number
->sourceObj : NodeList | HTMLCollection | ({ a: string; } & HTMLCollection)
+>sourceObj : NodeList | HTMLCollection
 >length : number
 }
 
diff --git a/tests/baselines/reference/controlFlowIfStatement.js b/tests/baselines/reference/controlFlowIfStatement.js
index a70c07d38dc1b..e40b831552f3d 100644
--- a/tests/baselines/reference/controlFlowIfStatement.js
+++ b/tests/baselines/reference/controlFlowIfStatement.js
@@ -35,6 +35,22 @@ function b() {
     }
     x; // string
 }
+function c<T>(data: string | T): T {
+    if (typeof data === 'string') {
+        return JSON.parse(data);
+    }
+    else {
+        return data;
+    }
+}
+function d<T extends string>(data: string | T): never {
+    if (typeof data === 'string') {
+        throw new Error('will always happen');
+    }
+    else {
+        return data;
+    }
+}
 
 
 //// [controlFlowIfStatement.js]
@@ -72,3 +88,19 @@ function b() {
     }
     x; // string
 }
+function c(data) {
+    if (typeof data === 'string') {
+        return JSON.parse(data);
+    }
+    else {
+        return data;
+    }
+}
+function d(data) {
+    if (typeof data === 'string') {
+        throw new Error('will always happen');
+    }
+    else {
+        return data;
+    }
+}
diff --git a/tests/baselines/reference/controlFlowIfStatement.symbols b/tests/baselines/reference/controlFlowIfStatement.symbols
index 1d85b31c9988f..e4d2bb9f184c0 100644
--- a/tests/baselines/reference/controlFlowIfStatement.symbols
+++ b/tests/baselines/reference/controlFlowIfStatement.symbols
@@ -71,4 +71,42 @@ function b() {
     x; // string
 >x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7))
 }
+function c<T>(data: string | T): T {
+>c : Symbol(c, Decl(controlFlowIfStatement.ts, 35, 1))
+>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11))
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14))
+>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11))
+>T : Symbol(T, Decl(controlFlowIfStatement.ts, 36, 11))
+
+    if (typeof data === 'string') {
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14))
+
+        return JSON.parse(data);
+>JSON.parse : Symbol(JSON.parse, Decl(lib.d.ts, --, --))
+>JSON : Symbol(JSON, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>parse : Symbol(JSON.parse, Decl(lib.d.ts, --, --))
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14))
+    }
+    else {
+        return data;
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 36, 14))
+    }
+}
+function d<T extends string>(data: string | T): never {
+>d : Symbol(d, Decl(controlFlowIfStatement.ts, 43, 1))
+>T : Symbol(T, Decl(controlFlowIfStatement.ts, 44, 11))
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29))
+>T : Symbol(T, Decl(controlFlowIfStatement.ts, 44, 11))
+
+    if (typeof data === 'string') {
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29))
+
+        throw new Error('will always happen');
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+    }
+    else {
+        return data;
+>data : Symbol(data, Decl(controlFlowIfStatement.ts, 44, 29))
+    }
+}
 
diff --git a/tests/baselines/reference/controlFlowIfStatement.types b/tests/baselines/reference/controlFlowIfStatement.types
index 716491ea58baa..79985378bf5bd 100644
--- a/tests/baselines/reference/controlFlowIfStatement.types
+++ b/tests/baselines/reference/controlFlowIfStatement.types
@@ -90,4 +90,51 @@ function b() {
     x; // string
 >x : string
 }
+function c<T>(data: string | T): T {
+>c : <T>(data: string | T) => T
+>T : T
+>data : string | T
+>T : T
+>T : T
+
+    if (typeof data === 'string') {
+>typeof data === 'string' : boolean
+>typeof data : string
+>data : string | T
+>'string' : "string"
+
+        return JSON.parse(data);
+>JSON.parse(data) : any
+>JSON.parse : (text: string, reviver?: (key: any, value: any) => any) => any
+>JSON : JSON
+>parse : (text: string, reviver?: (key: any, value: any) => any) => any
+>data : string
+    }
+    else {
+        return data;
+>data : T
+    }
+}
+function d<T extends string>(data: string | T): never {
+>d : <T extends string>(data: string | T) => never
+>T : T
+>data : string | T
+>T : T
+
+    if (typeof data === 'string') {
+>typeof data === 'string' : boolean
+>typeof data : string
+>data : string | T
+>'string' : "string"
+
+        throw new Error('will always happen');
+>new Error('will always happen') : Error
+>Error : ErrorConstructor
+>'will always happen' : string
+    }
+    else {
+        return data;
+>data : never
+    }
+}
 
diff --git a/tests/baselines/reference/controlFlowInstanceof.js b/tests/baselines/reference/controlFlowInstanceof.js
new file mode 100644
index 0000000000000..3f2287b46285a
--- /dev/null
+++ b/tests/baselines/reference/controlFlowInstanceof.js
@@ -0,0 +1,184 @@
+//// [controlFlowInstanceof.ts]
+
+// Repros from #10167
+
+function f1(s: Set<string> | Set<number>) {
+    s = new Set<number>();
+    s;  // Set<number>
+    if (s instanceof Set) {
+        s;  // Set<number>
+    }
+    s;  // Set<number>
+    s.add(42);
+}
+
+function f2(s: Set<string> | Set<number>) {
+    s = new Set<number>();
+    s;  // Set<number>
+    if (s instanceof Promise) {
+        s;  // Set<number> & Promise<any>
+    }
+    s;  // Set<number>
+    s.add(42);
+}
+
+function f3(s: Set<string> | Set<number>) {
+    s;  // Set<string> | Set<number>
+    if (s instanceof Set) {
+        s;  // Set<string> | Set<number>
+    }
+    else {
+        s;  // never
+    }
+}
+
+function f4(s: Set<string> | Set<number>) {
+    s = new Set<number>();
+    s;  // Set<number>
+    if (s instanceof Set) {
+        s;  // Set<number>
+    }
+    else {
+        s;  // never
+    }
+}
+
+// More tests
+
+class A { a: string }
+class B extends A { b: string }
+class C extends A { c: string }
+
+function foo(x: A | undefined) {
+    x;  // A | undefined
+    if (x instanceof B || x instanceof C) {
+        x;  // B | C
+    }
+    x;  // A | undefined
+    if (x instanceof B && x instanceof C) {
+        x;  // B & C
+    }
+    x;  // A | undefined
+    if (!x) {
+        return;
+    }
+    x;  // A
+    if (x instanceof B) {
+        x;  // B
+        if (x instanceof C) {
+            x;  // B & C
+        }
+        else {
+            x;  // B
+        }
+        x;  // B
+    }
+    else {
+        x;  // A
+    }
+    x;  // A
+}
+
+// X is neither assignable to Y nor a subtype of Y
+// Y is assignable to X, but not a subtype of X
+
+interface X {
+    x?: string;
+}
+
+class Y {
+    y: string;
+}
+
+function goo(x: X) {
+    x;
+    if (x instanceof Y) {
+        x.y;
+    }
+    x;
+}
+
+//// [controlFlowInstanceof.js]
+// Repros from #10167
+function f1(s) {
+    s = new Set();
+    s; // Set<number>
+    if (s instanceof Set) {
+        s; // Set<number>
+    }
+    s; // Set<number>
+    s.add(42);
+}
+function f2(s) {
+    s = new Set();
+    s; // Set<number>
+    if (s instanceof Promise) {
+        s; // Set<number> & Promise<any>
+    }
+    s; // Set<number>
+    s.add(42);
+}
+function f3(s) {
+    s; // Set<string> | Set<number>
+    if (s instanceof Set) {
+        s; // Set<string> | Set<number>
+    }
+    else {
+        s; // never
+    }
+}
+function f4(s) {
+    s = new Set();
+    s; // Set<number>
+    if (s instanceof Set) {
+        s; // Set<number>
+    }
+    else {
+        s; // never
+    }
+}
+// More tests
+class A {
+}
+class B extends A {
+}
+class C extends A {
+}
+function foo(x) {
+    x; // A | undefined
+    if (x instanceof B || x instanceof C) {
+        x; // B | C
+    }
+    x; // A | undefined
+    if (x instanceof B && x instanceof C) {
+        x; // B & C
+    }
+    x; // A | undefined
+    if (!x) {
+        return;
+    }
+    x; // A
+    if (x instanceof B) {
+        x; // B
+        if (x instanceof C) {
+            x; // B & C
+        }
+        else {
+            x; // B
+        }
+        x; // B
+    }
+    else {
+        x; // A
+    }
+    x; // A
+}
+class Y {
+}
+function goo(x) {
+    x;
+    if (x instanceof Y) {
+        x.y;
+    }
+    x;
+}
diff --git a/tests/baselines/reference/controlFlowInstanceof.symbols b/tests/baselines/reference/controlFlowInstanceof.symbols
new file mode 100644
index 0000000000000..3189482799013
--- /dev/null
+++ b/tests/baselines/reference/controlFlowInstanceof.symbols
@@ -0,0 +1,232 @@
+=== tests/cases/compiler/controlFlowInstanceof.ts ===
+
+// Repros from #10167
+
+function f1(s: Set<string> | Set<number>) {
+>f1 : Symbol(f1, Decl(controlFlowInstanceof.ts, 0, 0))
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s = new Set<number>();
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+
+    if (s instanceof Set) {
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+        s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+    }
+    s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+
+    s.add(42);
+>s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 3, 12))
+>add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+}
+
+function f2(s: Set<string> | Set<number>) {
+>f2 : Symbol(f2, Decl(controlFlowInstanceof.ts, 11, 1))
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s = new Set<number>();
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+
+    if (s instanceof Promise) {
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+
+        s;  // Set<number> & Promise<any>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+    }
+    s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+
+    s.add(42);
+>s.add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
+>add : Symbol(Set.add, Decl(lib.es2015.collection.d.ts, --, --))
+}
+
+function f3(s: Set<string> | Set<number>) {
+>f3 : Symbol(f3, Decl(controlFlowInstanceof.ts, 21, 1))
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s;  // Set<string> | Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12))
+
+    if (s instanceof Set) {
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+        s;  // Set<string> | Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12))
+    }
+    else {
+        s;  // never
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 23, 12))
+    }
+}
+
+function f4(s: Set<string> | Set<number>) {
+>f4 : Symbol(f4, Decl(controlFlowInstanceof.ts, 31, 1))
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s = new Set<number>();
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+    s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12))
+
+    if (s instanceof Set) {
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12))
+>Set : Symbol(Set, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --), Decl(lib.es2015.collection.d.ts, --, --))
+
+        s;  // Set<number>
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12))
+    }
+    else {
+        s;  // never
+>s : Symbol(s, Decl(controlFlowInstanceof.ts, 33, 12))
+    }
+}
+
+// More tests
+
+class A { a: string }
+>A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1))
+>a : Symbol(A.a, Decl(controlFlowInstanceof.ts, 46, 9))
+
+class B extends A { b: string }
+>B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21))
+>A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1))
+>b : Symbol(B.b, Decl(controlFlowInstanceof.ts, 47, 19))
+
+class C extends A { c: string }
+>C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31))
+>A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1))
+>c : Symbol(C.c, Decl(controlFlowInstanceof.ts, 48, 19))
+
+function foo(x: A | undefined) {
+>foo : Symbol(foo, Decl(controlFlowInstanceof.ts, 48, 31))
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>A : Symbol(A, Decl(controlFlowInstanceof.ts, 42, 1))
+
+    x;  // A | undefined
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+
+    if (x instanceof B || x instanceof C) {
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21))
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31))
+
+        x;  // B | C
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+    }
+    x;  // A | undefined
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+
+    if (x instanceof B && x instanceof C) {
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21))
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31))
+
+        x;  // B & C
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+    }
+    x;  // A | undefined
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+
+    if (!x) {
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+
+        return;
+    }
+    x;  // A
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+
+    if (x instanceof B) {
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>B : Symbol(B, Decl(controlFlowInstanceof.ts, 46, 21))
+
+        x;  // B
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+
+        if (x instanceof C) {
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+>C : Symbol(C, Decl(controlFlowInstanceof.ts, 47, 31))
+
+            x;  // B & C
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+        }
+        else {
+            x;  // B
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+        }
+        x;  // B
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+    }
+    else {
+        x;  // A
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+    }
+    x;  // A
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 50, 13))
+}
+
+// X is neither assignable to Y nor a subtype of Y
+// Y is assignable to X, but not a subtype of X
+
+interface X {
+>X : Symbol(X, Decl(controlFlowInstanceof.ts, 78, 1))
+
+    x?: string;
+>x : Symbol(X.x, Decl(controlFlowInstanceof.ts, 83, 13))
+}
+
+class Y {
+>Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 85, 1))
+
+    y: string;
+>y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9))
+}
+
+function goo(x: X) {
+>goo : Symbol(goo, Decl(controlFlowInstanceof.ts, 89, 1))
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13))
+>X : Symbol(X, Decl(controlFlowInstanceof.ts, 78, 1))
+
+    x;
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13))
+
+    if (x instanceof Y) {
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13))
+>Y : Symbol(Y, Decl(controlFlowInstanceof.ts, 85, 1))
+
+        x.y;
+>x.y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9))
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13))
+>y : Symbol(Y.y, Decl(controlFlowInstanceof.ts, 87, 9))
+    }
+    x;
+>x : Symbol(x, Decl(controlFlowInstanceof.ts, 91, 13))
+}
diff --git a/tests/baselines/reference/controlFlowInstanceof.types b/tests/baselines/reference/controlFlowInstanceof.types
new file mode 100644
index 0000000000000..e52d1a25b1d0d
--- /dev/null
+++ b/tests/baselines/reference/controlFlowInstanceof.types
@@ -0,0 +1,256 @@
+=== tests/cases/compiler/controlFlowInstanceof.ts ===
+
+// Repros from #10167
+
+function f1(s: Set<string> | Set<number>) {
+>f1 : (s: Set<string> | Set<number>) => void
+>s : Set<string> | Set<number>
+>Set : Set<T>
+>Set : Set<T>
+
+    s = new Set<number>();
+>s = new Set<number>() : Set<number>
+>s : Set<string> | Set<number>
+>new Set<number>() : Set<number>
+>Set : SetConstructor
+
+    s;  // Set<number>
+>s : Set<number>
+
+    if (s instanceof Set) {
+>s instanceof Set : boolean
+>s : Set<number>
+>Set : SetConstructor
+
+        s;  // Set<number>
+>s : Set<number>
+    }
+    s;  // Set<number>
+>s : Set<number>
+
+    s.add(42);
+>s.add(42) : Set<number>
+>s.add : (value: number) => Set<number>
+>s : Set<number>
+>add : (value: number) => Set<number>
+>42 : number
+}
+
+function f2(s: Set<string> | Set<number>) {
+>f2 : (s: Set<string> | Set<number>) => void
+>s : Set<string> | Set<number>
+>Set : Set<T>
+>Set : Set<T>
+
+    s = new Set<number>();
+>s = new Set<number>() : Set<number>
+>s : Set<string> | Set<number>
+>new Set<number>() : Set<number>
+>Set : SetConstructor
+
+    s;  // Set<number>
+>s : Set<number>
+
+    if (s instanceof Promise) {
+>s instanceof Promise : boolean
+>s : Set<number>
+>Promise : PromiseConstructor
+
+        s;  // Set<number> & Promise<any>
+>s : Set<number> & Promise<any>
+    }
+    s;  // Set<number>
+>s : Set<number>
+
+    s.add(42);
+>s.add(42) : Set<number>
+>s.add : (value: number) => Set<number>
+>s : Set<number>
+>add : (value: number) => Set<number>
+>42 : number
+}
+
+function f3(s: Set<string> | Set<number>) {
+>f3 : (s: Set<string> | Set<number>) => void
+>s : Set<string> | Set<number>
+>Set : Set<T>
+>Set : Set<T>
+
+    s;  // Set<string> | Set<number>
+>s : Set<string> | Set<number>
+
+    if (s instanceof Set) {
+>s instanceof Set : boolean
+>s : Set<string> | Set<number>
+>Set : SetConstructor
+
+        s;  // Set<string> | Set<number>
+>s : Set<string> | Set<number>
+    }
+    else {
+        s;  // never
+>s : never
+    }
+}
+
+function f4(s: Set<string> | Set<number>) {
+>f4 : (s: Set<string> | Set<number>) => void
+>s : Set<string> | Set<number>
+>Set : Set<T>
+>Set : Set<T>
+
+    s = new Set<number>();
+>s = new Set<number>() : Set<number>
+>s : Set<string> | Set<number>
+>new Set<number>() : Set<number>
+>Set : SetConstructor
+
+    s;  // Set<number>
+>s : Set<number>
+
+    if (s instanceof Set) {
+>s instanceof Set : boolean
+>s : Set<number>
+>Set : SetConstructor
+
+        s;  // Set<number>
+>s : Set<number>
+    }
+    else {
+        s;  // never
+>s : never
+    }
+}
+
+// More tests
+
+class A { a: string }
+>A : A
+>a : string
+
+class B extends A { b: string }
+>B : B
+>A : A
+>b : string
+
+class C extends A { c: string }
+>C : C
+>A : A
+>c : string
+
+function foo(x: A | undefined) {
+>foo : (x: A) => void
+>x : A
+>A : A
+
+    x;  // A | undefined
+>x : A
+
+    if (x instanceof B || x instanceof C) {
+>x instanceof B || x instanceof C : boolean
+>x instanceof B : boolean
+>x : A
+>B : typeof B
+>x instanceof C : boolean
+>x : A
+>C : typeof C
+
+        x;  // B | C
+>x : B | C
+    }
+    x;  // A | undefined
+>x : A
+
+    if (x instanceof B && x instanceof C) {
+>x instanceof B && x instanceof C : boolean
+>x instanceof B : boolean
+>x : A
+>B : typeof B
+>x instanceof C : boolean
+>x : B
+>C : typeof C
+
+        x;  // B & C
+>x : B & C
+    }
+    x;  // A | undefined
+>x : A
+
+    if (!x) {
+>!x : boolean
+>x : A
+
+        return;
+    }
+    x;  // A
+>x : A
+
+    if (x instanceof B) {
+>x instanceof B : boolean
+>x : A
+>B : typeof B
+
+        x;  // B
+>x : B
+
+        if (x instanceof C) {
+>x instanceof C : boolean
+>x : B
+>C : typeof C
+
+            x;  // B & C
+>x : B & C
+        }
+        else {
+            x;  // B
+>x : B
+        }
+        x;  // B
+>x : B
+    }
+    else {
+        x;  // A
+>x : A
+    }
+    x;  // A
+>x : A
+}
+
+// X is neither assignable to Y nor a subtype of Y
+// Y is assignable to X, but not a subtype of X
+
+interface X {
+>X : X
+
+    x?: string;
+>x : string
+}
+
+class Y {
+>Y : Y
+
+    y: string;
+>y : string
+}
+
+function goo(x: X) {
+>goo : (x: X) => void
+>x : X
+>X : X
+
+    x;
+>x : X
+
+    if (x instanceof Y) {
+>x instanceof Y : boolean
+>x : X
+>Y : typeof Y
+
+        x.y;
+>x.y : string
+>x : Y
+>y : string
+    }
+    x;
+>x : X
+}
diff --git a/tests/baselines/reference/declarationsAndAssignments.errors.txt b/tests/baselines/reference/declarationsAndAssignments.errors.txt
index 517eaafe4abbe..3ed9e241c3992 100644
--- a/tests/baselines/reference/declarationsAndAssignments.errors.txt
+++ b/tests/baselines/reference/declarationsAndAssignments.errors.txt
@@ -18,11 +18,9 @@ tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(73,14):
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(74,11): error TS2459: Type 'undefined[]' has no property 'a' and no string index signature.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(74,14): error TS2459: Type 'undefined[]' has no property 'b' and no string index signature.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(106,5): error TS2345: Argument of type '[number, [string, { y: boolean; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
-  Types of property '1' are incompatible.
-    Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
-      Types of property '1' are incompatible.
-        Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
-          Property 'x' is missing in type '{ y: boolean; }'.
+  Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
+    Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
+      Property 'x' is missing in type '{ y: boolean; }'.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,6): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,9): error TS2322: Type 'number' is not assignable to type 'string'.
 
@@ -174,11 +172,9 @@ tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,9):
     f14([2, ["abc", { y: false }]]);  // Error, no x
         ~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, [string, { y: boolean; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
-!!! error TS2345:   Types of property '1' are incompatible.
-!!! error TS2345:     Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
-!!! error TS2345:       Types of property '1' are incompatible.
-!!! error TS2345:         Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
-!!! error TS2345:           Property 'x' is missing in type '{ y: boolean; }'.
+!!! error TS2345:   Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
+!!! error TS2345:     Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
+!!! error TS2345:       Property 'x' is missing in type '{ y: boolean; }'.
     
     module M {
         export var [a, b] = [1, 2];
diff --git a/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt b/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt
new file mode 100644
index 0000000000000..c4585b8301fea
--- /dev/null
+++ b/tests/baselines/reference/decoratorOnClassConstructor2.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/decorators/class/constructor/2.ts(1,20): error TS2691: An import path cannot end with a '.ts' extension. Consider importing './0' instead.
+tests/cases/conformance/decorators/class/constructor/2.ts(2,19): error TS2691: An import path cannot end with a '.ts' extension. Consider importing './0' instead.
+
+
+==== tests/cases/conformance/decorators/class/constructor/0.ts (0 errors) ====
+    
+    export class base { }
+    export function foo(target: Object, propertyKey: string | symbol, parameterIndex: number) { }
+    
+==== tests/cases/conformance/decorators/class/constructor/2.ts (2 errors) ====
+    import {base} from "./0.ts"
+                       ~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.ts' extension. Consider importing './0' instead.
+    import {foo} from "./0.ts"
+                      ~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.ts' extension. Consider importing './0' instead.
+    export class C  extends base{
+        constructor(@foo prop: any) {
+            super();
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt
index 3348effe8225d..e22b23122d34d 100644
--- a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt
+++ b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt
@@ -2,8 +2,7 @@ tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAss
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(3,12): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(4,5): error TS2461: Type 'undefined' is not an array type.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(9,5): error TS2322: Type '[number, number, string]' is not assignable to type '[number, boolean, string]'.
-  Types of property '1' are incompatible.
-    Type 'number' is not assignable to type 'boolean'.
+  Type 'number' is not assignable to type 'boolean'.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(17,6): error TS2322: Type 'string' is not assignable to type 'Number'.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(22,5): error TS2322: Type 'number[]' is not assignable to type '[number, number]'.
   Property '0' is missing in type 'number[]'.
@@ -30,8 +29,7 @@ tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAss
     var [b0, b1, b2]: [number, boolean, string] = [1, 2, "string"];  // Error
         ~~~~~~~~~~~~
 !!! error TS2322: Type '[number, number, string]' is not assignable to type '[number, boolean, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'boolean'.
+!!! error TS2322:   Type 'number' is not assignable to type 'boolean'.
     interface J extends Array<Number> {
         2: number;
     }
diff --git a/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt b/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt
index 878bb38abf0fc..d76a4efe5f15a 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt
+++ b/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt
@@ -1,6 +1,5 @@
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(7,4): error TS2345: Argument of type '[number, string, string[][]]' is not assignable to parameter of type '[number, number, string[][]]'.
-  Types of property '1' are incompatible.
-    Type 'string' is not assignable to type 'number'.
+  Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(7,29): error TS1005: ',' expected.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(8,4): error TS2345: Argument of type '[number, number, string[][], string]' is not assignable to parameter of type '[number, number, string[][]]'.
   Types of property 'pop' are incompatible.
@@ -32,12 +31,9 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
   Types of property '2' are incompatible.
     Type 'boolean' is not assignable to type '[[any]]'.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(40,4): error TS2345: Argument of type '[number, number, [[string]]]' is not assignable to parameter of type '[any, any, [[number]]]'.
-  Types of property '2' are incompatible.
-    Type '[[string]]' is not assignable to type '[[number]]'.
-      Types of property '0' are incompatible.
-        Type '[string]' is not assignable to type '[number]'.
-          Types of property '0' are incompatible.
-            Type 'string' is not assignable to type 'number'.
+  Type '[[string]]' is not assignable to type '[[number]]'.
+    Type '[string]' is not assignable to type '[number]'.
+      Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(46,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(47,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(55,7): error TS2420: Class 'C4' incorrectly implements interface 'F2'.
@@ -62,8 +58,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
     a0([1, "string", [["world"]]);      // Error
        ~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, string, string[][]]' is not assignable to parameter of type '[number, number, string[][]]'.
-!!! error TS2345:   Types of property '1' are incompatible.
-!!! error TS2345:     Type 'string' is not assignable to type 'number'.
+!!! error TS2345:   Type 'string' is not assignable to type 'number'.
                                 ~
 !!! error TS1005: ',' expected.
     a0([1, 2, [["world"]], "string"]);  // Error
@@ -142,12 +137,9 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
     c6([1, 2, [["string"]]]);  // Error, implied type is [any, any, [[number]]]  // Use initializer
        ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, number, [[string]]]' is not assignable to parameter of type '[any, any, [[number]]]'.
-!!! error TS2345:   Types of property '2' are incompatible.
-!!! error TS2345:     Type '[[string]]' is not assignable to type '[[number]]'.
-!!! error TS2345:       Types of property '0' are incompatible.
-!!! error TS2345:         Type '[string]' is not assignable to type '[number]'.
-!!! error TS2345:           Types of property '0' are incompatible.
-!!! error TS2345:             Type 'string' is not assignable to type 'number'.
+!!! error TS2345:   Type '[[string]]' is not assignable to type '[[number]]'.
+!!! error TS2345:     Type '[string]' is not assignable to type '[number]'.
+!!! error TS2345:       Type 'string' is not assignable to type 'number'.
     
     // A parameter can be marked optional by following its name or binding pattern with a question mark (?)
     // or by including an initializer.  Initializers (including binding property or element initializers) are
diff --git a/tests/baselines/reference/destructuringParameterProperties2.errors.txt b/tests/baselines/reference/destructuringParameterProperties2.errors.txt
index ec0f400631fe4..deb039aa67db5 100644
--- a/tests/baselines/reference/destructuringParameterProperties2.errors.txt
+++ b/tests/baselines/reference/destructuringParameterProperties2.errors.txt
@@ -6,8 +6,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(9
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(13,21): error TS2339: Property 'b' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(17,21): error TS2339: Property 'c' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(21,27): error TS2345: Argument of type '[number, undefined, string]' is not assignable to parameter of type '[number, string, boolean]'.
-  Types of property '2' are incompatible.
-    Type 'string' is not assignable to type 'boolean'.
+  Type 'string' is not assignable to type 'boolean'.
 
 
 ==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts (8 errors) ====
@@ -48,8 +47,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(2
     var x = new C1(undefined, [0, undefined, ""]);
                               ~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, undefined, string]' is not assignable to parameter of type '[number, string, boolean]'.
-!!! error TS2345:   Types of property '2' are incompatible.
-!!! error TS2345:     Type 'string' is not assignable to type 'boolean'.
+!!! error TS2345:   Type 'string' is not assignable to type 'boolean'.
     var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()];
     
     var y = new C1(10, [0, "", true]);
diff --git a/tests/baselines/reference/destructuringParameterProperties5.errors.txt b/tests/baselines/reference/destructuringParameterProperties5.errors.txt
index 6f5801b7898c8..8eff6ad0febee 100644
--- a/tests/baselines/reference/destructuringParameterProperties5.errors.txt
+++ b/tests/baselines/reference/destructuringParameterProperties5.errors.txt
@@ -8,9 +8,8 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,62): error TS2339: Property 'y' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,72): error TS2339: Property 'z' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(11,19): error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
-  Types of property '0' are incompatible.
-    Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
-      Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
+  Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
+    Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
 
 
 ==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts (10 errors) ====
@@ -45,7 +44,6 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(1
     var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]);
                       ~~~~~~
 !!! error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
-!!! error TS2345:   Types of property '0' are incompatible.
-!!! error TS2345:     Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
-!!! error TS2345:       Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
+!!! error TS2345:   Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
+!!! error TS2345:     Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
     var [a_x1, a_x2, a_x3, a_y, a_z] = [a.x1, a.x2, a.x3, a.y, a.z];
\ No newline at end of file
diff --git a/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt b/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
index 1a6558377434e..bdbda6f9a96eb 100644
--- a/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
+++ b/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
@@ -2,12 +2,9 @@ tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(3
   Types of property 'a1' are incompatible.
     Type 'boolean' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(4,5): error TS2322: Type '[number, [[boolean]], boolean]' is not assignable to type '[number, [[string]], boolean]'.
-  Types of property '1' are incompatible.
-    Type '[[boolean]]' is not assignable to type '[[string]]'.
-      Types of property '0' are incompatible.
-        Type '[boolean]' is not assignable to type '[string]'.
-          Types of property '0' are incompatible.
-            Type 'boolean' is not assignable to type 'string'.
+  Type '[[boolean]]' is not assignable to type '[[string]]'.
+    Type '[boolean]' is not assignable to type '[string]'.
+      Type 'boolean' is not assignable to type 'string'.
 tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(9,25): error TS2322: Type '{ t1: boolean; t2: string; }' is not assignable to type '{ t1: boolean; t2: number; }'.
   Types of property 't2' are incompatible.
     Type 'string' is not assignable to type 'number'.
@@ -28,12 +25,9 @@ tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(1
     var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [[false]], true];  // Error
         ~~~~~~~~~~~~~~~~
 !!! error TS2322: Type '[number, [[boolean]], boolean]' is not assignable to type '[number, [[string]], boolean]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type '[[boolean]]' is not assignable to type '[[string]]'.
-!!! error TS2322:       Types of property '0' are incompatible.
-!!! error TS2322:         Type '[boolean]' is not assignable to type '[string]'.
-!!! error TS2322:           Types of property '0' are incompatible.
-!!! error TS2322:             Type 'boolean' is not assignable to type 'string'.
+!!! error TS2322:   Type '[[boolean]]' is not assignable to type '[[string]]'.
+!!! error TS2322:     Type '[boolean]' is not assignable to type '[string]'.
+!!! error TS2322:       Type 'boolean' is not assignable to type 'string'.
     
     // The type T associated with a destructuring variable declaration is determined as follows:
     //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
diff --git a/tests/baselines/reference/discriminantPropertyCheck.errors.txt b/tests/baselines/reference/discriminantPropertyCheck.errors.txt
new file mode 100644
index 0000000000000..41593c4b2245d
--- /dev/null
+++ b/tests/baselines/reference/discriminantPropertyCheck.errors.txt
@@ -0,0 +1,77 @@
+tests/cases/compiler/discriminantPropertyCheck.ts(30,9): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/discriminantPropertyCheck.ts(66,9): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/compiler/discriminantPropertyCheck.ts (2 errors) ====
+    
+    type Item = Item1 | Item2;
+    
+    interface Base {
+        bar: boolean;
+    }
+    
+    interface Item1 extends Base {
+        kind: "A";
+        foo: string | undefined;
+        baz: boolean;
+        qux: true;
+    }
+    
+    interface Item2 extends Base {
+        kind: "B";
+        foo: string | undefined;
+        baz: boolean;
+        qux: false;
+    }
+    
+    function goo1(x: Item) {
+        if (x.kind === "A" && x.foo !== undefined) {
+            x.foo.length;
+        }
+    }
+    
+    function goo2(x: Item) {
+        if (x.foo !== undefined && x.kind === "A") {
+            x.foo.length;  // Error, intervening discriminant guard
+            ~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+        }
+    }
+    
+    function foo1(x: Item) {
+        if (x.bar && x.foo !== undefined) {
+            x.foo.length;
+        }
+    }
+    
+    function foo2(x: Item) {
+        if (x.foo !== undefined && x.bar) {
+            x.foo.length;
+        }
+    }
+    
+    function foo3(x: Item) {
+        if (x.baz && x.foo !== undefined) {
+            x.foo.length;
+        }
+    }
+    
+    function foo4(x: Item) {
+        if (x.foo !== undefined && x.baz) {
+            x.foo.length;
+        }
+    }
+    
+    function foo5(x: Item) {
+        if (x.qux && x.foo !== undefined) {
+            x.foo.length;
+        }
+    }
+    
+    function foo6(x: Item) {
+        if (x.foo !== undefined && x.qux) {
+            x.foo.length;  // Error, intervening discriminant guard
+            ~~~~~
+!!! error TS2532: Object is possibly 'undefined'.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/discriminantPropertyCheck.js b/tests/baselines/reference/discriminantPropertyCheck.js
new file mode 100644
index 0000000000000..b75a6277735f7
--- /dev/null
+++ b/tests/baselines/reference/discriminantPropertyCheck.js
@@ -0,0 +1,111 @@
+//// [discriminantPropertyCheck.ts]
+
+type Item = Item1 | Item2;
+
+interface Base {
+    bar: boolean;
+}
+
+interface Item1 extends Base {
+    kind: "A";
+    foo: string | undefined;
+    baz: boolean;
+    qux: true;
+}
+
+interface Item2 extends Base {
+    kind: "B";
+    foo: string | undefined;
+    baz: boolean;
+    qux: false;
+}
+
+function goo1(x: Item) {
+    if (x.kind === "A" && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function goo2(x: Item) {
+    if (x.foo !== undefined && x.kind === "A") {
+        x.foo.length;  // Error, intervening discriminant guard
+    }
+}
+
+function foo1(x: Item) {
+    if (x.bar && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function foo2(x: Item) {
+    if (x.foo !== undefined && x.bar) {
+        x.foo.length;
+    }
+}
+
+function foo3(x: Item) {
+    if (x.baz && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function foo4(x: Item) {
+    if (x.foo !== undefined && x.baz) {
+        x.foo.length;
+    }
+}
+
+function foo5(x: Item) {
+    if (x.qux && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function foo6(x: Item) {
+    if (x.foo !== undefined && x.qux) {
+        x.foo.length;  // Error, intervening discriminant guard
+    }
+}
+
+//// [discriminantPropertyCheck.js]
+function goo1(x) {
+    if (x.kind === "A" && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+function goo2(x) {
+    if (x.foo !== undefined && x.kind === "A") {
+        x.foo.length; // Error, intervening discriminant guard
+    }
+}
+function foo1(x) {
+    if (x.bar && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+function foo2(x) {
+    if (x.foo !== undefined && x.bar) {
+        x.foo.length;
+    }
+}
+function foo3(x) {
+    if (x.baz && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+function foo4(x) {
+    if (x.foo !== undefined && x.baz) {
+        x.foo.length;
+    }
+}
+function foo5(x) {
+    if (x.qux && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+function foo6(x) {
+    if (x.foo !== undefined && x.qux) {
+        x.foo.length; // Error, intervening discriminant guard
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.js b/tests/baselines/reference/discriminantsAndNullOrUndefined.js
new file mode 100644
index 0000000000000..153950f8ab5d9
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.js
@@ -0,0 +1,44 @@
+//// [discriminantsAndNullOrUndefined.ts]
+
+// Repro from #10228
+
+interface A { kind: 'A'; }
+interface B { kind: 'B'; }
+
+type C = A | B | undefined;
+
+function never(_: never): never {
+    throw new Error();
+}
+
+function useA(_: A): void { }
+function useB(_: B): void { }
+
+declare var c: C;
+
+if (c !== undefined) {
+    switch (c.kind) {
+        case 'A': useA(c); break;
+        case 'B': useB(c); break;
+        default: never(c);
+    }
+}
+
+//// [discriminantsAndNullOrUndefined.js]
+// Repro from #10228
+function never(_) {
+    throw new Error();
+}
+function useA(_) { }
+function useB(_) { }
+if (c !== undefined) {
+    switch (c.kind) {
+        case 'A':
+            useA(c);
+            break;
+        case 'B':
+            useB(c);
+            break;
+        default: never(c);
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols b/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols
new file mode 100644
index 0000000000000..3f95fcf3a3fef
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.symbols
@@ -0,0 +1,61 @@
+=== tests/cases/compiler/discriminantsAndNullOrUndefined.ts ===
+
+// Repro from #10228
+
+interface A { kind: 'A'; }
+>A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0))
+>kind : Symbol(A.kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13))
+
+interface B { kind: 'B'; }
+>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26))
+>kind : Symbol(B.kind, Decl(discriminantsAndNullOrUndefined.ts, 4, 13))
+
+type C = A | B | undefined;
+>C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 4, 26))
+>A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0))
+>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26))
+
+function never(_: never): never {
+>never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 6, 27))
+>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 8, 15))
+
+    throw new Error();
+>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+}
+
+function useA(_: A): void { }
+>useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 10, 1))
+>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 12, 14))
+>A : Symbol(A, Decl(discriminantsAndNullOrUndefined.ts, 0, 0))
+
+function useB(_: B): void { }
+>useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 12, 29))
+>_ : Symbol(_, Decl(discriminantsAndNullOrUndefined.ts, 13, 14))
+>B : Symbol(B, Decl(discriminantsAndNullOrUndefined.ts, 3, 26))
+
+declare var c: C;
+>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11))
+>C : Symbol(C, Decl(discriminantsAndNullOrUndefined.ts, 4, 26))
+
+if (c !== undefined) {
+>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11))
+>undefined : Symbol(undefined)
+
+    switch (c.kind) {
+>c.kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13), Decl(discriminantsAndNullOrUndefined.ts, 4, 13))
+>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11))
+>kind : Symbol(kind, Decl(discriminantsAndNullOrUndefined.ts, 3, 13), Decl(discriminantsAndNullOrUndefined.ts, 4, 13))
+
+        case 'A': useA(c); break;
+>useA : Symbol(useA, Decl(discriminantsAndNullOrUndefined.ts, 10, 1))
+>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11))
+
+        case 'B': useB(c); break;
+>useB : Symbol(useB, Decl(discriminantsAndNullOrUndefined.ts, 12, 29))
+>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11))
+
+        default: never(c);
+>never : Symbol(never, Decl(discriminantsAndNullOrUndefined.ts, 6, 27))
+>c : Symbol(c, Decl(discriminantsAndNullOrUndefined.ts, 15, 11))
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndNullOrUndefined.types b/tests/baselines/reference/discriminantsAndNullOrUndefined.types
new file mode 100644
index 0000000000000..7a2918ab83b42
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndNullOrUndefined.types
@@ -0,0 +1,68 @@
+=== tests/cases/compiler/discriminantsAndNullOrUndefined.ts ===
+
+// Repro from #10228
+
+interface A { kind: 'A'; }
+>A : A
+>kind : "A"
+
+interface B { kind: 'B'; }
+>B : B
+>kind : "B"
+
+type C = A | B | undefined;
+>C : C
+>A : A
+>B : B
+
+function never(_: never): never {
+>never : (_: never) => never
+>_ : never
+
+    throw new Error();
+>new Error() : Error
+>Error : ErrorConstructor
+}
+
+function useA(_: A): void { }
+>useA : (_: A) => void
+>_ : A
+>A : A
+
+function useB(_: B): void { }
+>useB : (_: B) => void
+>_ : B
+>B : B
+
+declare var c: C;
+>c : C
+>C : C
+
+if (c !== undefined) {
+>c !== undefined : boolean
+>c : C
+>undefined : undefined
+
+    switch (c.kind) {
+>c.kind : "A" | "B"
+>c : A | B
+>kind : "A" | "B"
+
+        case 'A': useA(c); break;
+>'A' : "A"
+>useA(c) : void
+>useA : (_: A) => void
+>c : A
+
+        case 'B': useB(c); break;
+>'B' : "B"
+>useB(c) : void
+>useB : (_: B) => void
+>c : B
+
+        default: never(c);
+>never(c) : never
+>never : (_: never) => never
+>c : never
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.js b/tests/baselines/reference/discriminantsAndPrimitives.js
new file mode 100644
index 0000000000000..1d11781a70784
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndPrimitives.js
@@ -0,0 +1,84 @@
+//// [discriminantsAndPrimitives.ts]
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+    kind: "foo";
+    name: string;
+}
+
+interface Bar {
+    kind: "bar";
+    length: string;
+}
+
+function f1(x: Foo | Bar | string) {
+    if (typeof x !== 'string') {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+    if (typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+    if (x && typeof x !== "string") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+    if (x && typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+//// [discriminantsAndPrimitives.js]
+// Repro from #10257 plus other tests
+function f1(x) {
+    if (typeof x !== 'string') {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+function f2(x) {
+    if (typeof x === "object") {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+function f3(x) {
+    if (x && typeof x !== "string") {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+function f4(x) {
+    if (x && typeof x === "object") {
+        switch (x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.symbols b/tests/baselines/reference/discriminantsAndPrimitives.symbols
new file mode 100644
index 0000000000000..c84f32cd99073
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndPrimitives.symbols
@@ -0,0 +1,117 @@
+=== tests/cases/compiler/discriminantsAndPrimitives.ts ===
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+
+    kind: "foo";
+>kind : Symbol(Foo.kind, Decl(discriminantsAndPrimitives.ts, 3, 15))
+
+    name: string;
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+}
+
+interface Bar {
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    kind: "bar";
+>kind : Symbol(Bar.kind, Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+    length: string;
+>length : Symbol(Bar.length, Decl(discriminantsAndPrimitives.ts, 9, 16))
+}
+
+function f1(x: Foo | Bar | string) {
+>f1 : Symbol(f1, Decl(discriminantsAndPrimitives.ts, 11, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (typeof x !== 'string') {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 13, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+>f2 : Symbol(f2, Decl(discriminantsAndPrimitives.ts, 20, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (typeof x === "object") {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 22, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+>f3 : Symbol(f3, Decl(discriminantsAndPrimitives.ts, 29, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (x && typeof x !== "string") {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 31, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+>f4 : Symbol(f4, Decl(discriminantsAndPrimitives.ts, 38, 1))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>Foo : Symbol(Foo, Decl(discriminantsAndPrimitives.ts, 0, 0))
+>Bar : Symbol(Bar, Decl(discriminantsAndPrimitives.ts, 6, 1))
+
+    if (x && typeof x === "object") {
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+
+        switch(x.kind) {
+>x.kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>kind : Symbol(kind, Decl(discriminantsAndPrimitives.ts, 3, 15), Decl(discriminantsAndPrimitives.ts, 8, 15))
+
+            case 'foo':
+                x.name;
+>x.name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+>x : Symbol(x, Decl(discriminantsAndPrimitives.ts, 40, 12))
+>name : Symbol(Foo.name, Decl(discriminantsAndPrimitives.ts, 4, 16))
+        }
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndPrimitives.types b/tests/baselines/reference/discriminantsAndPrimitives.types
new file mode 100644
index 0000000000000..d3e1b70e59911
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndPrimitives.types
@@ -0,0 +1,141 @@
+=== tests/cases/compiler/discriminantsAndPrimitives.ts ===
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+>Foo : Foo
+
+    kind: "foo";
+>kind : "foo"
+
+    name: string;
+>name : string
+}
+
+interface Bar {
+>Bar : Bar
+
+    kind: "bar";
+>kind : "bar"
+
+    length: string;
+>length : string
+}
+
+function f1(x: Foo | Bar | string) {
+>f1 : (x: string | Foo | Bar) => void
+>x : string | Foo | Bar
+>Foo : Foo
+>Bar : Bar
+
+    if (typeof x !== 'string') {
+>typeof x !== 'string' : boolean
+>typeof x : string
+>x : string | Foo | Bar
+>'string' : "string"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+>f2 : (x: string | Foo | Bar | undefined) => void
+>x : string | Foo | Bar | undefined
+>Foo : Foo
+>Bar : Bar
+
+    if (typeof x === "object") {
+>typeof x === "object" : boolean
+>typeof x : string
+>x : string | Foo | Bar | undefined
+>"object" : "object"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+>f3 : (x: string | Foo | Bar | null) => void
+>x : string | Foo | Bar | null
+>Foo : Foo
+>Bar : Bar
+>null : null
+
+    if (x && typeof x !== "string") {
+>x && typeof x !== "string" : boolean | "" | null
+>x : string | Foo | Bar | null
+>typeof x !== "string" : boolean
+>typeof x : string
+>x : string | Foo | Bar
+>"string" : "string"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+>f4 : (x: string | number | Foo | Bar | null) => void
+>x : string | number | Foo | Bar | null
+>Foo : Foo
+>Bar : Bar
+>null : null
+
+    if (x && typeof x === "object") {
+>x && typeof x === "object" : boolean | "" | 0 | null
+>x : string | number | Foo | Bar | null
+>typeof x === "object" : boolean
+>typeof x : string
+>x : string | number | Foo | Bar
+>"object" : "object"
+
+        switch(x.kind) {
+>x.kind : "foo" | "bar"
+>x : Foo | Bar
+>kind : "foo" | "bar"
+
+            case 'foo':
+>'foo' : "foo"
+
+                x.name;
+>x.name : string
+>x : Foo
+>name : string
+        }
+    }
+}
diff --git a/tests/baselines/reference/discriminantsAndTypePredicates.js b/tests/baselines/reference/discriminantsAndTypePredicates.js
new file mode 100644
index 0000000000000..66cfe056ab711
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndTypePredicates.js
@@ -0,0 +1,59 @@
+//// [discriminantsAndTypePredicates.ts]
+// Repro from #10145
+
+interface A { type: 'A' }
+interface B { type: 'B' }
+
+function isA(x: A | B): x is A { return x.type === 'A'; }
+function isB(x: A | B): x is B { return x.type === 'B'; }
+
+function foo1(x: A | B): any {
+    x;  // A | B
+    if (isA(x)) {
+        return x;  // A
+    }
+    x;  // B
+    if (isB(x)) {
+        return x;  // B
+    }
+    x;  // never
+}
+
+function foo2(x: A | B): any {
+    x;  // A | B
+    if (x.type === 'A') {
+        return x;  // A
+    }
+    x;  // B
+    if (x.type === 'B') {
+        return x;  // B
+    }
+    x;  // never
+}
+
+//// [discriminantsAndTypePredicates.js]
+// Repro from #10145
+function isA(x) { return x.type === 'A'; }
+function isB(x) { return x.type === 'B'; }
+function foo1(x) {
+    x; // A | B
+    if (isA(x)) {
+        return x; // A
+    }
+    x; // B
+    if (isB(x)) {
+        return x; // B
+    }
+    x; // never
+}
+function foo2(x) {
+    x; // A | B
+    if (x.type === 'A') {
+        return x; // A
+    }
+    x; // B
+    if (x.type === 'B') {
+        return x; // B
+    }
+    x; // never
+}
diff --git a/tests/baselines/reference/discriminantsAndTypePredicates.symbols b/tests/baselines/reference/discriminantsAndTypePredicates.symbols
new file mode 100644
index 0000000000000..4f4128239364f
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndTypePredicates.symbols
@@ -0,0 +1,94 @@
+=== tests/cases/compiler/discriminantsAndTypePredicates.ts ===
+// Repro from #10145
+
+interface A { type: 'A' }
+>A : Symbol(A, Decl(discriminantsAndTypePredicates.ts, 0, 0))
+>type : Symbol(A.type, Decl(discriminantsAndTypePredicates.ts, 2, 13))
+
+interface B { type: 'B' }
+>B : Symbol(B, Decl(discriminantsAndTypePredicates.ts, 2, 25))
+>type : Symbol(B.type, Decl(discriminantsAndTypePredicates.ts, 3, 13))
+
+function isA(x: A | B): x is A { return x.type === 'A'; }
+>isA : Symbol(isA, Decl(discriminantsAndTypePredicates.ts, 3, 25))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 5, 13))
+>A : Symbol(A, Decl(discriminantsAndTypePredicates.ts, 0, 0))
+>B : Symbol(B, Decl(discriminantsAndTypePredicates.ts, 2, 25))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 5, 13))
+>A : Symbol(A, Decl(discriminantsAndTypePredicates.ts, 0, 0))
+>x.type : Symbol(type, Decl(discriminantsAndTypePredicates.ts, 2, 13), Decl(discriminantsAndTypePredicates.ts, 3, 13))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 5, 13))
+>type : Symbol(type, Decl(discriminantsAndTypePredicates.ts, 2, 13), Decl(discriminantsAndTypePredicates.ts, 3, 13))
+
+function isB(x: A | B): x is B { return x.type === 'B'; }
+>isB : Symbol(isB, Decl(discriminantsAndTypePredicates.ts, 5, 57))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 6, 13))
+>A : Symbol(A, Decl(discriminantsAndTypePredicates.ts, 0, 0))
+>B : Symbol(B, Decl(discriminantsAndTypePredicates.ts, 2, 25))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 6, 13))
+>B : Symbol(B, Decl(discriminantsAndTypePredicates.ts, 2, 25))
+>x.type : Symbol(type, Decl(discriminantsAndTypePredicates.ts, 2, 13), Decl(discriminantsAndTypePredicates.ts, 3, 13))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 6, 13))
+>type : Symbol(type, Decl(discriminantsAndTypePredicates.ts, 2, 13), Decl(discriminantsAndTypePredicates.ts, 3, 13))
+
+function foo1(x: A | B): any {
+>foo1 : Symbol(foo1, Decl(discriminantsAndTypePredicates.ts, 6, 57))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+>A : Symbol(A, Decl(discriminantsAndTypePredicates.ts, 0, 0))
+>B : Symbol(B, Decl(discriminantsAndTypePredicates.ts, 2, 25))
+
+    x;  // A | B
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+
+    if (isA(x)) {
+>isA : Symbol(isA, Decl(discriminantsAndTypePredicates.ts, 3, 25))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+
+        return x;  // A
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+    }
+    x;  // B
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+
+    if (isB(x)) {
+>isB : Symbol(isB, Decl(discriminantsAndTypePredicates.ts, 5, 57))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+
+        return x;  // B
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+    }
+    x;  // never
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 8, 14))
+}
+
+function foo2(x: A | B): any {
+>foo2 : Symbol(foo2, Decl(discriminantsAndTypePredicates.ts, 18, 1))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+>A : Symbol(A, Decl(discriminantsAndTypePredicates.ts, 0, 0))
+>B : Symbol(B, Decl(discriminantsAndTypePredicates.ts, 2, 25))
+
+    x;  // A | B
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+
+    if (x.type === 'A') {
+>x.type : Symbol(type, Decl(discriminantsAndTypePredicates.ts, 2, 13), Decl(discriminantsAndTypePredicates.ts, 3, 13))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+>type : Symbol(type, Decl(discriminantsAndTypePredicates.ts, 2, 13), Decl(discriminantsAndTypePredicates.ts, 3, 13))
+
+        return x;  // A
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+    }
+    x;  // B
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+
+    if (x.type === 'B') {
+>x.type : Symbol(B.type, Decl(discriminantsAndTypePredicates.ts, 3, 13))
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+>type : Symbol(B.type, Decl(discriminantsAndTypePredicates.ts, 3, 13))
+
+        return x;  // B
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+    }
+    x;  // never
+>x : Symbol(x, Decl(discriminantsAndTypePredicates.ts, 20, 14))
+}
diff --git a/tests/baselines/reference/discriminantsAndTypePredicates.types b/tests/baselines/reference/discriminantsAndTypePredicates.types
new file mode 100644
index 0000000000000..f7675b1475601
--- /dev/null
+++ b/tests/baselines/reference/discriminantsAndTypePredicates.types
@@ -0,0 +1,104 @@
+=== tests/cases/compiler/discriminantsAndTypePredicates.ts ===
+// Repro from #10145
+
+interface A { type: 'A' }
+>A : A
+>type : "A"
+
+interface B { type: 'B' }
+>B : B
+>type : "B"
+
+function isA(x: A | B): x is A { return x.type === 'A'; }
+>isA : (x: A | B) => x is A
+>x : A | B
+>A : A
+>B : B
+>x : any
+>A : A
+>x.type === 'A' : boolean
+>x.type : "A" | "B"
+>x : A | B
+>type : "A" | "B"
+>'A' : "A"
+
+function isB(x: A | B): x is B { return x.type === 'B'; }
+>isB : (x: A | B) => x is B
+>x : A | B
+>A : A
+>B : B
+>x : any
+>B : B
+>x.type === 'B' : boolean
+>x.type : "A" | "B"
+>x : A | B
+>type : "A" | "B"
+>'B' : "B"
+
+function foo1(x: A | B): any {
+>foo1 : (x: A | B) => any
+>x : A | B
+>A : A
+>B : B
+
+    x;  // A | B
+>x : A | B
+
+    if (isA(x)) {
+>isA(x) : boolean
+>isA : (x: A | B) => x is A
+>x : A | B
+
+        return x;  // A
+>x : A
+    }
+    x;  // B
+>x : B
+
+    if (isB(x)) {
+>isB(x) : boolean
+>isB : (x: A | B) => x is B
+>x : B
+
+        return x;  // B
+>x : B
+    }
+    x;  // never
+>x : never
+}
+
+function foo2(x: A | B): any {
+>foo2 : (x: A | B) => any
+>x : A | B
+>A : A
+>B : B
+
+    x;  // A | B
+>x : A | B
+
+    if (x.type === 'A') {
+>x.type === 'A' : boolean
+>x.type : "A" | "B"
+>x : A | B
+>type : "A" | "B"
+>'A' : "A"
+
+        return x;  // A
+>x : A
+    }
+    x;  // B
+>x : B
+
+    if (x.type === 'B') {
+>x.type === 'B' : boolean
+>x.type : "B"
+>x : B
+>type : "B"
+>'B' : "B"
+
+        return x;  // B
+>x : B
+    }
+    x;  // never
+>x : never
+}
diff --git a/tests/baselines/reference/emitCapturingThisInTupleDestructuring1.errors.txt b/tests/baselines/reference/emitCapturingThisInTupleDestructuring1.errors.txt
new file mode 100644
index 0000000000000..d0f11d056ca53
--- /dev/null
+++ b/tests/baselines/reference/emitCapturingThisInTupleDestructuring1.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts(3,17): error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts(3,29): error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+
+
+==== tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts (2 errors) ====
+    declare function wrapper(x: any);
+    wrapper((array: [any]) => {
+        [this.test, this.test1, this.test2] = array;  // even though there is a compiler error, we should still emit lexical capture for "this"
+                    ~~~~~~~~~~
+!!! error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+                                ~~~~~~~~~~
+!!! error TS2493: Tuple type '[any]' with length '1' cannot be assigned to tuple with length '3'.
+    });
\ No newline at end of file
diff --git a/tests/baselines/reference/emitCapturingThisInTupleDestructuring1.js b/tests/baselines/reference/emitCapturingThisInTupleDestructuring1.js
new file mode 100644
index 0000000000000..9dd7453ba4f17
--- /dev/null
+++ b/tests/baselines/reference/emitCapturingThisInTupleDestructuring1.js
@@ -0,0 +1,11 @@
+//// [emitCapturingThisInTupleDestructuring1.ts]
+declare function wrapper(x: any);
+wrapper((array: [any]) => {
+    [this.test, this.test1, this.test2] = array;  // even though there is a compiler error, we should still emit lexical capture for "this"
+});
+
+//// [emitCapturingThisInTupleDestructuring1.js]
+var _this = this;
+wrapper(function (array) {
+    _this.test = array[0], _this.test1 = array[1], _this.test2 = array[2]; // even though there is a compiler error, we should still emit lexical capture for "this"
+});
diff --git a/tests/baselines/reference/emitCapturingThisInTupleDestructuring2.errors.txt b/tests/baselines/reference/emitCapturingThisInTupleDestructuring2.errors.txt
new file mode 100644
index 0000000000000..25207e28c79a9
--- /dev/null
+++ b/tests/baselines/reference/emitCapturingThisInTupleDestructuring2.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts(8,39): error TS2493: Tuple type '[number, number]' with length '2' cannot be assigned to tuple with length '3'.
+
+
+==== tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts (1 errors) ====
+    var array1: [number, number] = [1, 2];
+    
+    class B {
+        test: number;
+        test1: any;
+        test2: any;
+        method() {
+            () => [this.test, this.test1, this.test2] = array1; // even though there is a compiler error, we should still emit lexical capture for "this" 
+                                          ~~~~~~~~~~
+!!! error TS2493: Tuple type '[number, number]' with length '2' cannot be assigned to tuple with length '3'.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/emitCapturingThisInTupleDestructuring2.js b/tests/baselines/reference/emitCapturingThisInTupleDestructuring2.js
new file mode 100644
index 0000000000000..890b9d4c9b843
--- /dev/null
+++ b/tests/baselines/reference/emitCapturingThisInTupleDestructuring2.js
@@ -0,0 +1,23 @@
+//// [emitCapturingThisInTupleDestructuring2.ts]
+var array1: [number, number] = [1, 2];
+
+class B {
+    test: number;
+    test1: any;
+    test2: any;
+    method() {
+        () => [this.test, this.test1, this.test2] = array1; // even though there is a compiler error, we should still emit lexical capture for "this" 
+    }
+}
+
+//// [emitCapturingThisInTupleDestructuring2.js]
+var array1 = [1, 2];
+var B = (function () {
+    function B() {
+    }
+    B.prototype.method = function () {
+        var _this = this;
+        (function () { return _this.test = array1[0], _this.test1 = array1[1], _this.test2 = array1[2], array1; }); // even though there is a compiler error, we should still emit lexical capture for "this" 
+    };
+    return B;
+}());
diff --git a/tests/baselines/reference/exportDefaultProperty.js b/tests/baselines/reference/exportDefaultProperty.js
new file mode 100644
index 0000000000000..10ba6d6419a60
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty.js
@@ -0,0 +1,76 @@
+//// [tests/cases/compiler/exportDefaultProperty.ts] ////
+
+//// [declarations.d.ts]
+// This test is just like exportEqualsProperty, but with `export default`.
+
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export default foo.bar;
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+}
+
+//// [a.ts]
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export default A.B;
+
+//// [b.ts]
+export default "foo".length;
+
+//// [index.ts]
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+import X = fooBar.X;
+import X2 from "foobarx";
+const x: X = X;
+const x2: X2 = X2;
+
+import B from "./a";
+const b: B = new B(B.b);
+
+import fooLength from "./b";
+fooLength + 1;
+
+
+//// [a.js]
+"use strict";
+var A;
+(function (A) {
+    var B = (function () {
+        function B(b) {
+        }
+        return B;
+    }());
+    A.B = B;
+    var B;
+    (function (B) {
+        B.b = 0;
+    })(B = A.B || (A.B = {}));
+})(A || (A = {}));
+exports.__esModule = true;
+exports["default"] = A.B;
+//// [b.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = "foo".length;
+//// [index.js]
+"use strict";
+/// <reference path="declarations.d.ts" />
+var foobar_1 = require("foobar");
+var X = foobar_1["default"].X;
+var foobarx_1 = require("foobarx");
+var x = X;
+var x2 = foobarx_1["default"];
+var a_1 = require("./a");
+var b = new a_1["default"](a_1["default"].b);
+var b_1 = require("./b");
+b_1["default"] + 1;
diff --git a/tests/baselines/reference/exportDefaultProperty.symbols b/tests/baselines/reference/exportDefaultProperty.symbols
new file mode 100644
index 0000000000000..f9edcd154cc05
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty.symbols
@@ -0,0 +1,92 @@
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
+
+import X = fooBar.X;
+>X : Symbol(X, Decl(index.ts, 1, 28))
+>fooBar : Symbol(fooBar, Decl(index.ts, 1, 6))
+>X : Symbol(fooBar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+
+import X2 from "foobarx";
+>X2 : Symbol(X2, Decl(index.ts, 3, 6))
+
+const x: X = X;
+>x : Symbol(x, Decl(index.ts, 4, 5))
+>X : Symbol(X, Decl(index.ts, 1, 28))
+>X : Symbol(X, Decl(index.ts, 1, 28))
+
+const x2: X2 = X2;
+>x2 : Symbol(x2, Decl(index.ts, 5, 5))
+>X2 : Symbol(X2, Decl(index.ts, 3, 6))
+>X2 : Symbol(X2, Decl(index.ts, 3, 6))
+
+import B from "./a";
+>B : Symbol(B, Decl(index.ts, 7, 6))
+
+const b: B = new B(B.b);
+>b : Symbol(b, Decl(index.ts, 8, 5))
+>B : Symbol(B, Decl(index.ts, 7, 6))
+>B : Symbol(B, Decl(index.ts, 7, 6))
+>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
+>B : Symbol(B, Decl(index.ts, 7, 6))
+>b : Symbol(B.b, Decl(a.ts, 2, 37))
+
+import fooLength from "./b";
+>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
+
+fooLength + 1;
+>fooLength : Symbol(fooLength, Decl(index.ts, 10, 6))
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportEqualsProperty, but with `export default`.
+
+declare namespace foo.bar {
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
+
+    export type X = number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+
+    export const X: number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+declare module "foobar" {
+    export default foo.bar;
+>foo.bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(default, Decl(declarations.d.ts, 2, 22))
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+>foo.bar.X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>X : Symbol(default, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+    export class B { constructor(b: number) {} }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 1, 33))
+
+    export namespace B { export const b: number = 0; }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 2, 37))
+}
+export default A.B;
+>A.B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>A : Symbol(A, Decl(a.ts, 0, 0))
+>B : Symbol(default, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+
+=== tests/cases/compiler/b.ts ===
+export default "foo".length;
+>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/exportDefaultProperty.types b/tests/baselines/reference/exportDefaultProperty.types
new file mode 100644
index 0000000000000..47cfabfbc165e
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty.types
@@ -0,0 +1,97 @@
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+>fooBar : typeof fooBar
+
+import X = fooBar.X;
+>X : number
+>fooBar : typeof fooBar
+>X : number
+
+import X2 from "foobarx";
+>X2 : number
+
+const x: X = X;
+>x : number
+>X : number
+>X : number
+
+const x2: X2 = X2;
+>x2 : number
+>X2 : number
+>X2 : number
+
+import B from "./a";
+>B : typeof B
+
+const b: B = new B(B.b);
+>b : B
+>B : B
+>new B(B.b) : B
+>B : typeof B
+>B.b : number
+>B : typeof B
+>b : number
+
+import fooLength from "./b";
+>fooLength : number
+
+fooLength + 1;
+>fooLength + 1 : number
+>fooLength : number
+>1 : number
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportEqualsProperty, but with `export default`.
+
+declare namespace foo.bar {
+>foo : typeof foo
+>bar : typeof bar
+
+    export type X = number;
+>X : number
+
+    export const X: number;
+>X : number
+}
+
+declare module "foobar" {
+    export default foo.bar;
+>foo.bar : typeof default
+>foo : typeof foo
+>bar : typeof default
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+>foo.bar.X : number
+>foo.bar : typeof foo.bar
+>foo : typeof foo
+>bar : typeof foo.bar
+>X : number
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : typeof A
+
+    export class B { constructor(b: number) {} }
+>B : B
+>b : number
+
+    export namespace B { export const b: number = 0; }
+>B : typeof B
+>b : number
+>0 : number
+}
+export default A.B;
+>A.B : typeof default
+>A : typeof A
+>B : typeof default
+
+=== tests/cases/compiler/b.ts ===
+export default "foo".length;
+>"foo".length : number
+>"foo" : string
+>length : number
+
diff --git a/tests/baselines/reference/exportDefaultProperty2.js b/tests/baselines/reference/exportDefaultProperty2.js
new file mode 100644
index 0000000000000..2b0a5dce526d7
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty2.js
@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/exportDefaultProperty2.ts] ////
+
+//// [a.ts]
+// This test is just like exportEqualsProperty2, but with `export default`.
+
+class C {
+    static B: number;
+}
+namespace C {
+    export interface B { c: number }
+}
+
+export default C.B;
+
+//// [b.ts]
+import B from "./a";
+const x: B = { c: B };
+
+
+//// [a.js]
+// This test is just like exportEqualsProperty2, but with `export default`.
+"use strict";
+var C = (function () {
+    function C() {
+    }
+    return C;
+}());
+exports.__esModule = true;
+exports["default"] = C.B;
+//// [b.js]
+"use strict";
+var a_1 = require("./a");
+var x = { c: a_1["default"] };
diff --git a/tests/baselines/reference/exportDefaultProperty2.symbols b/tests/baselines/reference/exportDefaultProperty2.symbols
new file mode 100644
index 0000000000000..d3d7519aa94ef
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty2.symbols
@@ -0,0 +1,32 @@
+=== tests/cases/compiler/a.ts ===
+// This test is just like exportEqualsProperty2, but with `export default`.
+
+class C {
+>C : Symbol(C, Decl(a.ts, 0, 0), Decl(a.ts, 4, 1))
+
+    static B: number;
+>B : Symbol(default, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+}
+namespace C {
+>C : Symbol(C, Decl(a.ts, 0, 0), Decl(a.ts, 4, 1))
+
+    export interface B { c: number }
+>B : Symbol(B, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+>c : Symbol(B.c, Decl(a.ts, 6, 24))
+}
+
+export default C.B;
+>C.B : Symbol(default, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+>C : Symbol(C, Decl(a.ts, 0, 0), Decl(a.ts, 4, 1))
+>B : Symbol(default, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+
+=== tests/cases/compiler/b.ts ===
+import B from "./a";
+>B : Symbol(B, Decl(b.ts, 0, 6))
+
+const x: B = { c: B };
+>x : Symbol(x, Decl(b.ts, 1, 5))
+>B : Symbol(B, Decl(b.ts, 0, 6))
+>c : Symbol(c, Decl(b.ts, 1, 14))
+>B : Symbol(B, Decl(b.ts, 0, 6))
+
diff --git a/tests/baselines/reference/exportDefaultProperty2.types b/tests/baselines/reference/exportDefaultProperty2.types
new file mode 100644
index 0000000000000..2fc9d3a475057
--- /dev/null
+++ b/tests/baselines/reference/exportDefaultProperty2.types
@@ -0,0 +1,33 @@
+=== tests/cases/compiler/a.ts ===
+// This test is just like exportEqualsProperty2, but with `export default`.
+
+class C {
+>C : C
+
+    static B: number;
+>B : number
+}
+namespace C {
+>C : typeof C
+
+    export interface B { c: number }
+>B : B
+>c : number
+}
+
+export default C.B;
+>C.B : number
+>C : typeof C
+>B : number
+
+=== tests/cases/compiler/b.ts ===
+import B from "./a";
+>B : number
+
+const x: B = { c: B };
+>x : B
+>B : B
+>{ c: B } : { c: number; }
+>c : number
+>B : number
+
diff --git a/tests/baselines/reference/exportEqualsProperty.js b/tests/baselines/reference/exportEqualsProperty.js
new file mode 100644
index 0000000000000..2fd8a8c851178
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty.js
@@ -0,0 +1,72 @@
+//// [tests/cases/compiler/exportEqualsProperty.ts] ////
+
+//// [declarations.d.ts]
+// This test is just like exportDefaultProperty, but with `export =`.
+
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export = foo.bar;
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+}
+
+//// [a.ts]
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export = A.B;
+
+//// [b.ts]
+export = "foo".length;
+
+//// [index.ts]
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+import X2 = require("foobarx");
+const x: X = X;
+const x2: X2 = X2;
+
+import B = require("./a");
+const b: B = new B(B.b);
+
+import fooLength = require("./b");
+fooLength + 1;
+
+
+//// [a.js]
+"use strict";
+var A;
+(function (A) {
+    var B = (function () {
+        function B(b) {
+        }
+        return B;
+    }());
+    A.B = B;
+    var B;
+    (function (B) {
+        B.b = 0;
+    })(B = A.B || (A.B = {}));
+})(A || (A = {}));
+module.exports = A.B;
+//// [b.js]
+"use strict";
+module.exports = "foo".length;
+//// [index.js]
+"use strict";
+/// <reference path="declarations.d.ts" />
+var foobar_1 = require("foobar");
+var X2 = require("foobarx");
+var x = foobar_1.X;
+var x2 = X2;
+var B = require("./a");
+var b = new B(B.b);
+var fooLength = require("./b");
+fooLength + 1;
diff --git a/tests/baselines/reference/exportEqualsProperty.symbols b/tests/baselines/reference/exportEqualsProperty.symbols
new file mode 100644
index 0000000000000..43c9ed3251868
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty.symbols
@@ -0,0 +1,87 @@
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+>X : Symbol(X, Decl(index.ts, 1, 8))
+
+import X2 = require("foobarx");
+>X2 : Symbol(X2, Decl(index.ts, 1, 27))
+
+const x: X = X;
+>x : Symbol(x, Decl(index.ts, 3, 5))
+>X : Symbol(X, Decl(index.ts, 1, 8))
+>X : Symbol(X, Decl(index.ts, 1, 8))
+
+const x2: X2 = X2;
+>x2 : Symbol(x2, Decl(index.ts, 4, 5))
+>X2 : Symbol(X2, Decl(index.ts, 1, 27))
+>X2 : Symbol(X2, Decl(index.ts, 1, 27))
+
+import B = require("./a");
+>B : Symbol(B, Decl(index.ts, 4, 18))
+
+const b: B = new B(B.b);
+>b : Symbol(b, Decl(index.ts, 7, 5))
+>B : Symbol(B, Decl(index.ts, 4, 18))
+>B : Symbol(B, Decl(index.ts, 4, 18))
+>B.b : Symbol(B.b, Decl(a.ts, 2, 37))
+>B : Symbol(B, Decl(index.ts, 4, 18))
+>b : Symbol(B.b, Decl(a.ts, 2, 37))
+
+import fooLength = require("./b");
+>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
+
+fooLength + 1;
+>fooLength : Symbol(fooLength, Decl(index.ts, 7, 24))
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportDefaultProperty, but with `export =`.
+
+declare namespace foo.bar {
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(bar, Decl(declarations.d.ts, 2, 22))
+
+    export type X = number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+
+    export const X: number;
+>X : Symbol(X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+declare module "foobar" {
+    export = foo.bar;
+>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+>foo.bar.X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+>foo.bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>foo : Symbol(foo, Decl(declarations.d.ts, 0, 0))
+>bar : Symbol(foo.bar, Decl(declarations.d.ts, 2, 22))
+>X : Symbol(foo.bar.X, Decl(declarations.d.ts, 2, 27), Decl(declarations.d.ts, 4, 16))
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : Symbol(A, Decl(a.ts, 0, 0))
+
+    export class B { constructor(b: number) {} }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 1, 33))
+
+    export namespace B { export const b: number = 0; }
+>B : Symbol(B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>b : Symbol(b, Decl(a.ts, 2, 37))
+}
+export = A.B;
+>A.B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+>A : Symbol(A, Decl(a.ts, 0, 0))
+>B : Symbol(A.B, Decl(a.ts, 0, 13), Decl(a.ts, 1, 48))
+
+=== tests/cases/compiler/b.ts ===
+export = "foo".length;
+>"foo".length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
diff --git a/tests/baselines/reference/exportEqualsProperty.types b/tests/baselines/reference/exportEqualsProperty.types
new file mode 100644
index 0000000000000..a92af53b12bd4
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty.types
@@ -0,0 +1,92 @@
+=== tests/cases/compiler/index.ts ===
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+>X : number
+
+import X2 = require("foobarx");
+>X2 : number
+
+const x: X = X;
+>x : number
+>X : number
+>X : number
+
+const x2: X2 = X2;
+>x2 : number
+>X2 : number
+>X2 : number
+
+import B = require("./a");
+>B : typeof B
+
+const b: B = new B(B.b);
+>b : B
+>B : B
+>new B(B.b) : B
+>B : typeof B
+>B.b : number
+>B : typeof B
+>b : number
+
+import fooLength = require("./b");
+>fooLength : number
+
+fooLength + 1;
+>fooLength + 1 : number
+>fooLength : number
+>1 : number
+
+=== tests/cases/compiler/declarations.d.ts ===
+// This test is just like exportDefaultProperty, but with `export =`.
+
+declare namespace foo.bar {
+>foo : typeof foo
+>bar : typeof bar
+
+    export type X = number;
+>X : number
+
+    export const X: number;
+>X : number
+}
+
+declare module "foobar" {
+    export = foo.bar;
+>foo.bar : typeof foo.bar
+>foo : typeof foo
+>bar : typeof foo.bar
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+>foo.bar.X : number
+>foo.bar : typeof foo.bar
+>foo : typeof foo
+>bar : typeof foo.bar
+>X : number
+}
+
+=== tests/cases/compiler/a.ts ===
+namespace A {
+>A : typeof A
+
+    export class B { constructor(b: number) {} }
+>B : B
+>b : number
+
+    export namespace B { export const b: number = 0; }
+>B : typeof B
+>b : number
+>0 : number
+}
+export = A.B;
+>A.B : typeof A.B
+>A : typeof A
+>B : typeof A.B
+
+=== tests/cases/compiler/b.ts ===
+export = "foo".length;
+>"foo".length : number
+>"foo" : string
+>length : number
+
diff --git a/tests/baselines/reference/exportEqualsProperty2.js b/tests/baselines/reference/exportEqualsProperty2.js
new file mode 100644
index 0000000000000..b5d91431722e3
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty2.js
@@ -0,0 +1,32 @@
+//// [tests/cases/compiler/exportEqualsProperty2.ts] ////
+
+//// [a.ts]
+// This test is just like exportDefaultProperty2, but with `export =`.
+
+class C {
+    static B: number;
+}
+namespace C {
+    export interface B { c: number }
+}
+
+export = C.B;
+
+//// [b.ts]
+import B = require("./a");
+const x: B = { c: B };
+
+
+//// [a.js]
+// This test is just like exportDefaultProperty2, but with `export =`.
+"use strict";
+var C = (function () {
+    function C() {
+    }
+    return C;
+}());
+module.exports = C.B;
+//// [b.js]
+"use strict";
+var B = require("./a");
+var x = { c: B };
diff --git a/tests/baselines/reference/exportEqualsProperty2.symbols b/tests/baselines/reference/exportEqualsProperty2.symbols
new file mode 100644
index 0000000000000..df7eda76661cf
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty2.symbols
@@ -0,0 +1,32 @@
+=== tests/cases/compiler/b.ts ===
+import B = require("./a");
+>B : Symbol(B, Decl(b.ts, 0, 0))
+
+const x: B = { c: B };
+>x : Symbol(x, Decl(b.ts, 1, 5))
+>B : Symbol(B, Decl(b.ts, 0, 0))
+>c : Symbol(c, Decl(b.ts, 1, 14))
+>B : Symbol(B, Decl(b.ts, 0, 0))
+
+=== tests/cases/compiler/a.ts ===
+// This test is just like exportDefaultProperty2, but with `export =`.
+
+class C {
+>C : Symbol(C, Decl(a.ts, 0, 0), Decl(a.ts, 4, 1))
+
+    static B: number;
+>B : Symbol(C.B, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+}
+namespace C {
+>C : Symbol(C, Decl(a.ts, 0, 0), Decl(a.ts, 4, 1))
+
+    export interface B { c: number }
+>B : Symbol(B, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+>c : Symbol(B.c, Decl(a.ts, 6, 24))
+}
+
+export = C.B;
+>C.B : Symbol(C.B, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+>C : Symbol(C, Decl(a.ts, 0, 0), Decl(a.ts, 4, 1))
+>B : Symbol(C.B, Decl(a.ts, 2, 9), Decl(a.ts, 5, 13))
+
diff --git a/tests/baselines/reference/exportEqualsProperty2.types b/tests/baselines/reference/exportEqualsProperty2.types
new file mode 100644
index 0000000000000..4594cbfd01541
--- /dev/null
+++ b/tests/baselines/reference/exportEqualsProperty2.types
@@ -0,0 +1,33 @@
+=== tests/cases/compiler/b.ts ===
+import B = require("./a");
+>B : number
+
+const x: B = { c: B };
+>x : B
+>B : B
+>{ c: B } : { c: number; }
+>c : number
+>B : number
+
+=== tests/cases/compiler/a.ts ===
+// This test is just like exportDefaultProperty2, but with `export =`.
+
+class C {
+>C : C
+
+    static B: number;
+>B : number
+}
+namespace C {
+>C : typeof C
+
+    export interface B { c: number }
+>B : B
+>c : number
+}
+
+export = C.B;
+>C.B : number
+>C : typeof C
+>B : number
+
diff --git a/tests/baselines/reference/genericCallWithTupleType.errors.txt b/tests/baselines/reference/genericCallWithTupleType.errors.txt
index 0194dc61311ee..617c4f7159b54 100644
--- a/tests/baselines/reference/genericCallWithTupleType.errors.txt
+++ b/tests/baselines/reference/genericCallWithTupleType.errors.txt
@@ -6,11 +6,9 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(14,1): error TS2322: Type '{ a: string; }' is not assignable to type 'string | number'.
   Type '{ a: string; }' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(22,1): error TS2322: Type '[number, string]' is not assignable to type '[string, number]'.
-  Types of property '0' are incompatible.
-    Type 'number' is not assignable to type 'string'.
+  Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(23,1): error TS2322: Type '[{}, {}]' is not assignable to type '[string, number]'.
-  Types of property '0' are incompatible.
-    Type '{}' is not assignable to type 'string'.
+  Type '{}' is not assignable to type 'string'.
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(24,1): error TS2322: Type '[{}]' is not assignable to type '[{}, {}]'.
   Property '1' is missing in type '[{}]'.
 
@@ -49,13 +47,11 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup
     i1.tuple1 = [5, "foo"];
     ~~~~~~~~~
 !!! error TS2322: Type '[number, string]' is not assignable to type '[string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
     i1.tuple1 = [{}, {}];
     ~~~~~~~~~
 !!! error TS2322: Type '[{}, {}]' is not assignable to type '[string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type '{}' is not assignable to type 'string'.
+!!! error TS2322:   Type '{}' is not assignable to type 'string'.
     i2.tuple1 = [{}];
     ~~~~~~~~~
 !!! error TS2322: Type '[{}]' is not assignable to type '[{}, {}]'.
diff --git a/tests/baselines/reference/getterControlFlowStrictNull.errors.txt b/tests/baselines/reference/getterControlFlowStrictNull.errors.txt
new file mode 100644
index 0000000000000..1c4f02d6a756f
--- /dev/null
+++ b/tests/baselines/reference/getterControlFlowStrictNull.errors.txt
@@ -0,0 +1,27 @@
+tests/cases/compiler/getterControlFlowStrictNull.ts(2,9): error TS2366: Function lacks ending return statement and return type does not include 'undefined'.
+tests/cases/compiler/getterControlFlowStrictNull.ts(11,14): error TS2366: Function lacks ending return statement and return type does not include 'undefined'.
+
+
+==== tests/cases/compiler/getterControlFlowStrictNull.ts (2 errors) ====
+    class A {
+       a(): string | null {
+            ~~~~~~~~~~~~~
+!!! error TS2366: Function lacks ending return statement and return type does not include 'undefined'.
+            if (Math.random() > 0.5) {
+                return '';
+            }
+    
+            // it does error here as expected
+        }
+    }
+    class B {
+        get a(): string | null {
+                 ~~~~~~~~~~~~~
+!!! error TS2366: Function lacks ending return statement and return type does not include 'undefined'.
+            if (Math.random() > 0.5) {
+                return '';
+            }
+    
+            // it should error here because it returns undefined
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/getterControlFlowStrictNull.js b/tests/baselines/reference/getterControlFlowStrictNull.js
new file mode 100644
index 0000000000000..c3f7e410d0a7c
--- /dev/null
+++ b/tests/baselines/reference/getterControlFlowStrictNull.js
@@ -0,0 +1,47 @@
+//// [getterControlFlowStrictNull.ts]
+class A {
+   a(): string | null {
+        if (Math.random() > 0.5) {
+            return '';
+        }
+
+        // it does error here as expected
+    }
+}
+class B {
+    get a(): string | null {
+        if (Math.random() > 0.5) {
+            return '';
+        }
+
+        // it should error here because it returns undefined
+    }
+}
+
+//// [getterControlFlowStrictNull.js]
+var A = (function () {
+    function A() {
+    }
+    A.prototype.a = function () {
+        if (Math.random() > 0.5) {
+            return '';
+        }
+        // it does error here as expected
+    };
+    return A;
+}());
+var B = (function () {
+    function B() {
+    }
+    Object.defineProperty(B.prototype, "a", {
+        get: function () {
+            if (Math.random() > 0.5) {
+                return '';
+            }
+            // it should error here because it returns undefined
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return B;
+}());
diff --git a/tests/baselines/reference/implicitConstParameters.errors.txt b/tests/baselines/reference/implicitConstParameters.errors.txt
new file mode 100644
index 0000000000000..95ff60d71f809
--- /dev/null
+++ b/tests/baselines/reference/implicitConstParameters.errors.txt
@@ -0,0 +1,65 @@
+tests/cases/compiler/implicitConstParameters.ts(39,27): error TS2532: Object is possibly 'undefined'.
+tests/cases/compiler/implicitConstParameters.ts(45,27): error TS2532: Object is possibly 'undefined'.
+
+
+==== tests/cases/compiler/implicitConstParameters.ts (2 errors) ====
+    
+    function doSomething(cb: () => void) {
+        cb();
+    }
+    
+    function fn(x: number | string) {
+      if (typeof x === 'number') {
+          doSomething(() => x.toFixed());
+      }
+    }
+    
+    function f1(x: string | undefined) {
+        if (!x) {
+            return;
+        }
+        doSomething(() => x.length);
+    }
+    
+    function f2(x: string | undefined) {
+        if (x) {
+            doSomething(() => {
+                doSomething(() => x.length);
+            });
+        }
+    }
+    
+    function f3(x: string | undefined) {
+        inner();
+        function inner() {
+            if (x) {
+                doSomething(() => x.length);
+            }
+        }
+    }
+    
+    function f4(x: string | undefined) {
+        x = "abc";  // causes x to be considered non-const
+        if (x) {
+            doSomething(() => x.length);
+                              ~
+!!! error TS2532: Object is possibly 'undefined'.
+        }
+    }
+    
+    function f5(x: string | undefined) {
+        if (x) {
+            doSomething(() => x.length);
+                              ~
+!!! error TS2532: Object is possibly 'undefined'.
+        }
+        x = "abc";  // causes x to be considered non-const
+    }
+    
+    
+    function f6(x: string | undefined) {
+        const y = x || "";
+        if (x) {
+            doSomething(() => y.length);
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/implicitConstParameters.js b/tests/baselines/reference/implicitConstParameters.js
new file mode 100644
index 0000000000000..a5faf5b125354
--- /dev/null
+++ b/tests/baselines/reference/implicitConstParameters.js
@@ -0,0 +1,106 @@
+//// [implicitConstParameters.ts]
+
+function doSomething(cb: () => void) {
+    cb();
+}
+
+function fn(x: number | string) {
+  if (typeof x === 'number') {
+      doSomething(() => x.toFixed());
+  }
+}
+
+function f1(x: string | undefined) {
+    if (!x) {
+        return;
+    }
+    doSomething(() => x.length);
+}
+
+function f2(x: string | undefined) {
+    if (x) {
+        doSomething(() => {
+            doSomething(() => x.length);
+        });
+    }
+}
+
+function f3(x: string | undefined) {
+    inner();
+    function inner() {
+        if (x) {
+            doSomething(() => x.length);
+        }
+    }
+}
+
+function f4(x: string | undefined) {
+    x = "abc";  // causes x to be considered non-const
+    if (x) {
+        doSomething(() => x.length);
+    }
+}
+
+function f5(x: string | undefined) {
+    if (x) {
+        doSomething(() => x.length);
+    }
+    x = "abc";  // causes x to be considered non-const
+}
+
+
+function f6(x: string | undefined) {
+    const y = x || "";
+    if (x) {
+        doSomething(() => y.length);
+    }
+}
+
+//// [implicitConstParameters.js]
+function doSomething(cb) {
+    cb();
+}
+function fn(x) {
+    if (typeof x === 'number') {
+        doSomething(function () { return x.toFixed(); });
+    }
+}
+function f1(x) {
+    if (!x) {
+        return;
+    }
+    doSomething(function () { return x.length; });
+}
+function f2(x) {
+    if (x) {
+        doSomething(function () {
+            doSomething(function () { return x.length; });
+        });
+    }
+}
+function f3(x) {
+    inner();
+    function inner() {
+        if (x) {
+            doSomething(function () { return x.length; });
+        }
+    }
+}
+function f4(x) {
+    x = "abc"; // causes x to be considered non-const
+    if (x) {
+        doSomething(function () { return x.length; });
+    }
+}
+function f5(x) {
+    if (x) {
+        doSomething(function () { return x.length; });
+    }
+    x = "abc"; // causes x to be considered non-const
+}
+function f6(x) {
+    var y = x || "";
+    if (x) {
+        doSomething(function () { return y.length; });
+    }
+}
diff --git a/tests/baselines/reference/indexWithUndefinedAndNull.js b/tests/baselines/reference/indexWithUndefinedAndNull.js
new file mode 100644
index 0000000000000..f885323efae32
--- /dev/null
+++ b/tests/baselines/reference/indexWithUndefinedAndNull.js
@@ -0,0 +1,22 @@
+//// [indexWithUndefinedAndNull.ts]
+interface N {
+    [n: number]: string;
+}
+interface S {
+    [s: string]: number;
+}
+let n: N;
+let s: S;
+let str: string = n[undefined];
+str = n[null];
+let num: number = s[undefined];
+num = s[null];
+
+
+//// [indexWithUndefinedAndNull.js]
+var n;
+var s;
+var str = n[undefined];
+str = n[null];
+var num = s[undefined];
+num = s[null];
diff --git a/tests/baselines/reference/indexWithUndefinedAndNull.symbols b/tests/baselines/reference/indexWithUndefinedAndNull.symbols
new file mode 100644
index 0000000000000..15e8bbdbf41fe
--- /dev/null
+++ b/tests/baselines/reference/indexWithUndefinedAndNull.symbols
@@ -0,0 +1,39 @@
+=== tests/cases/compiler/indexWithUndefinedAndNull.ts ===
+interface N {
+>N : Symbol(N, Decl(indexWithUndefinedAndNull.ts, 0, 0))
+
+    [n: number]: string;
+>n : Symbol(n, Decl(indexWithUndefinedAndNull.ts, 1, 5))
+}
+interface S {
+>S : Symbol(S, Decl(indexWithUndefinedAndNull.ts, 2, 1))
+
+    [s: string]: number;
+>s : Symbol(s, Decl(indexWithUndefinedAndNull.ts, 4, 5))
+}
+let n: N;
+>n : Symbol(n, Decl(indexWithUndefinedAndNull.ts, 6, 3))
+>N : Symbol(N, Decl(indexWithUndefinedAndNull.ts, 0, 0))
+
+let s: S;
+>s : Symbol(s, Decl(indexWithUndefinedAndNull.ts, 7, 3))
+>S : Symbol(S, Decl(indexWithUndefinedAndNull.ts, 2, 1))
+
+let str: string = n[undefined];
+>str : Symbol(str, Decl(indexWithUndefinedAndNull.ts, 8, 3))
+>n : Symbol(n, Decl(indexWithUndefinedAndNull.ts, 6, 3))
+>undefined : Symbol(undefined)
+
+str = n[null];
+>str : Symbol(str, Decl(indexWithUndefinedAndNull.ts, 8, 3))
+>n : Symbol(n, Decl(indexWithUndefinedAndNull.ts, 6, 3))
+
+let num: number = s[undefined];
+>num : Symbol(num, Decl(indexWithUndefinedAndNull.ts, 10, 3))
+>s : Symbol(s, Decl(indexWithUndefinedAndNull.ts, 7, 3))
+>undefined : Symbol(undefined)
+
+num = s[null];
+>num : Symbol(num, Decl(indexWithUndefinedAndNull.ts, 10, 3))
+>s : Symbol(s, Decl(indexWithUndefinedAndNull.ts, 7, 3))
+
diff --git a/tests/baselines/reference/indexWithUndefinedAndNull.types b/tests/baselines/reference/indexWithUndefinedAndNull.types
new file mode 100644
index 0000000000000..07b6050503a57
--- /dev/null
+++ b/tests/baselines/reference/indexWithUndefinedAndNull.types
@@ -0,0 +1,47 @@
+=== tests/cases/compiler/indexWithUndefinedAndNull.ts ===
+interface N {
+>N : N
+
+    [n: number]: string;
+>n : number
+}
+interface S {
+>S : S
+
+    [s: string]: number;
+>s : string
+}
+let n: N;
+>n : N
+>N : N
+
+let s: S;
+>s : S
+>S : S
+
+let str: string = n[undefined];
+>str : string
+>n[undefined] : string
+>n : N
+>undefined : undefined
+
+str = n[null];
+>str = n[null] : string
+>str : string
+>n[null] : string
+>n : N
+>null : null
+
+let num: number = s[undefined];
+>num : number
+>s[undefined] : number
+>s : S
+>undefined : undefined
+
+num = s[null];
+>num = s[null] : number
+>num : number
+>s[null] : number
+>s : S
+>null : null
+
diff --git a/tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.errors.txt b/tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.errors.txt
new file mode 100644
index 0000000000000..a1fce75c54e9c
--- /dev/null
+++ b/tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.errors.txt
@@ -0,0 +1,40 @@
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(9,19): error TS2454: Variable 'n' is used before being assigned.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(9,19): error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(10,7): error TS2454: Variable 'n' is used before being assigned.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(10,7): error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(11,19): error TS2454: Variable 's' is used before being assigned.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(11,19): error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(12,7): error TS2454: Variable 's' is used before being assigned.
+tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts(12,7): error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+
+
+==== tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts (8 errors) ====
+    interface N {
+        [n: number]: string;
+    }
+    interface S {
+        [s: string]: number;
+    }
+    let n: N;
+    let s: S;
+    let str: string = n[undefined];
+                      ~
+!!! error TS2454: Variable 'n' is used before being assigned.
+                      ~~~~~~~~~~~~
+!!! error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+    str = n[null];
+          ~
+!!! error TS2454: Variable 'n' is used before being assigned.
+          ~~~~~~~
+!!! error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+    let num: number = s[undefined];
+                      ~
+!!! error TS2454: Variable 's' is used before being assigned.
+                      ~~~~~~~~~~~~
+!!! error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+    num = s[null];
+          ~
+!!! error TS2454: Variable 's' is used before being assigned.
+          ~~~~~~~
+!!! error TS2342: An index expression argument must be of type 'string', 'number', 'symbol', or 'any'.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.js b/tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.js
new file mode 100644
index 0000000000000..9300b7c054921
--- /dev/null
+++ b/tests/baselines/reference/indexWithUndefinedAndNullStrictNullChecks.js
@@ -0,0 +1,22 @@
+//// [indexWithUndefinedAndNullStrictNullChecks.ts]
+interface N {
+    [n: number]: string;
+}
+interface S {
+    [s: string]: number;
+}
+let n: N;
+let s: S;
+let str: string = n[undefined];
+str = n[null];
+let num: number = s[undefined];
+num = s[null];
+
+
+//// [indexWithUndefinedAndNullStrictNullChecks.js]
+var n;
+var s;
+var str = n[undefined];
+str = n[null];
+var num = s[undefined];
+num = s[null];
diff --git a/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.js b/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.js
new file mode 100644
index 0000000000000..97be21377229d
--- /dev/null
+++ b/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.js
@@ -0,0 +1,172 @@
+//// [instanceofWithStructurallyIdenticalTypes.ts]
+// Repro from #7271
+
+class C1 { item: string }
+class C2 { item: string[] }
+class C3 { item: string }
+
+function foo1(x: C1 | C2 | C3): string {
+    if (x instanceof C1) {
+        return x.item;
+    }
+    else if (x instanceof C2) {
+        return x.item[0];
+    }
+    else if (x instanceof C3) {
+        return x.item;
+    }
+    return "error";
+}
+
+function isC1(c: C1 | C2 | C3): c is C1 { return c instanceof C1 }
+function isC2(c: C1 | C2 | C3): c is C2 { return c instanceof C2 }
+function isC3(c: C1 | C2 | C3): c is C3 { return c instanceof C3 }
+
+function foo2(x: C1 | C2 | C3): string {
+    if (isC1(x)) {
+        return x.item;
+    }
+    else if (isC2(x)) {
+        return x.item[0];
+    }
+    else if (isC3(x)) {
+        return x.item;
+    }
+    return "error";
+}
+
+// More tests
+
+class A { a: string }
+class A1 extends A { }
+class A2 { a: string }
+class B extends A { b: string }
+
+function goo(x: A) {
+    if (x instanceof A) {
+        x;  // A
+    }
+    else {
+        x;  // never
+    }
+    if (x instanceof A1) {
+        x;  // A1
+    }
+    else {
+        x;  // A
+    }
+    if (x instanceof A2) {
+        x;  // A2
+    }
+    else {
+        x;  // A
+    }
+    if (x instanceof B) {
+        x;  // B
+    }
+    else {
+        x;  // A
+    }
+}
+
+
+//// [instanceofWithStructurallyIdenticalTypes.js]
+// Repro from #7271
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var C1 = (function () {
+    function C1() {
+    }
+    return C1;
+}());
+var C2 = (function () {
+    function C2() {
+    }
+    return C2;
+}());
+var C3 = (function () {
+    function C3() {
+    }
+    return C3;
+}());
+function foo1(x) {
+    if (x instanceof C1) {
+        return x.item;
+    }
+    else if (x instanceof C2) {
+        return x.item[0];
+    }
+    else if (x instanceof C3) {
+        return x.item;
+    }
+    return "error";
+}
+function isC1(c) { return c instanceof C1; }
+function isC2(c) { return c instanceof C2; }
+function isC3(c) { return c instanceof C3; }
+function foo2(x) {
+    if (isC1(x)) {
+        return x.item;
+    }
+    else if (isC2(x)) {
+        return x.item[0];
+    }
+    else if (isC3(x)) {
+        return x.item;
+    }
+    return "error";
+}
+// More tests
+var A = (function () {
+    function A() {
+    }
+    return A;
+}());
+var A1 = (function (_super) {
+    __extends(A1, _super);
+    function A1() {
+        _super.apply(this, arguments);
+    }
+    return A1;
+}(A));
+var A2 = (function () {
+    function A2() {
+    }
+    return A2;
+}());
+var B = (function (_super) {
+    __extends(B, _super);
+    function B() {
+        _super.apply(this, arguments);
+    }
+    return B;
+}(A));
+function goo(x) {
+    if (x instanceof A) {
+        x; // A
+    }
+    else {
+        x; // never
+    }
+    if (x instanceof A1) {
+        x; // A1
+    }
+    else {
+        x; // A
+    }
+    if (x instanceof A2) {
+        x; // A2
+    }
+    else {
+        x; // A
+    }
+    if (x instanceof B) {
+        x; // B
+    }
+    else {
+        x; // A
+    }
+}
diff --git a/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.symbols b/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.symbols
new file mode 100644
index 0000000000000..f2eb40eea47a1
--- /dev/null
+++ b/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.symbols
@@ -0,0 +1,192 @@
+=== tests/cases/compiler/instanceofWithStructurallyIdenticalTypes.ts ===
+// Repro from #7271
+
+class C1 { item: string }
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>item : Symbol(C1.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 10))
+
+class C2 { item: string[] }
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>item : Symbol(C2.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 10))
+
+class C3 { item: string }
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+>item : Symbol(C3.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 4, 10))
+
+function foo1(x: C1 | C2 | C3): string {
+>foo1 : Symbol(foo1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 4, 25))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+
+    if (x instanceof C1) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+
+        return x.item;
+>x.item : Symbol(C1.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 10))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>item : Symbol(C1.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 10))
+    }
+    else if (x instanceof C2) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+
+        return x.item[0];
+>x.item : Symbol(C2.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 10))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>item : Symbol(C2.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 10))
+    }
+    else if (x instanceof C3) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+
+        return x.item;
+>x.item : Symbol(C3.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 4, 10))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 6, 14))
+>item : Symbol(C3.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 4, 10))
+    }
+    return "error";
+}
+
+function isC1(c: C1 | C2 | C3): c is C1 { return c instanceof C1 }
+>isC1 : Symbol(isC1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 17, 1))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 19, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 19, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 19, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+
+function isC2(c: C1 | C2 | C3): c is C2 { return c instanceof C2 }
+>isC2 : Symbol(isC2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 19, 66))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 20, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 20, 14))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 20, 14))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+
+function isC3(c: C1 | C2 | C3): c is C3 { return c instanceof C3 }
+>isC3 : Symbol(isC3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 20, 66))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 21, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 21, 14))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+>c : Symbol(c, Decl(instanceofWithStructurallyIdenticalTypes.ts, 21, 14))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+
+function foo2(x: C1 | C2 | C3): string {
+>foo2 : Symbol(foo2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 21, 66))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+>C1 : Symbol(C1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 0, 0))
+>C2 : Symbol(C2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 25))
+>C3 : Symbol(C3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 27))
+
+    if (isC1(x)) {
+>isC1 : Symbol(isC1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 17, 1))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+
+        return x.item;
+>x.item : Symbol(C1.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 10))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+>item : Symbol(C1.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 2, 10))
+    }
+    else if (isC2(x)) {
+>isC2 : Symbol(isC2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 19, 66))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+
+        return x.item[0];
+>x.item : Symbol(C2.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 10))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+>item : Symbol(C2.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 3, 10))
+    }
+    else if (isC3(x)) {
+>isC3 : Symbol(isC3, Decl(instanceofWithStructurallyIdenticalTypes.ts, 20, 66))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+
+        return x.item;
+>x.item : Symbol(C3.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 4, 10))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 23, 14))
+>item : Symbol(C3.item, Decl(instanceofWithStructurallyIdenticalTypes.ts, 4, 10))
+    }
+    return "error";
+}
+
+// More tests
+
+class A { a: string }
+>A : Symbol(A, Decl(instanceofWithStructurallyIdenticalTypes.ts, 34, 1))
+>a : Symbol(A.a, Decl(instanceofWithStructurallyIdenticalTypes.ts, 38, 9))
+
+class A1 extends A { }
+>A1 : Symbol(A1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 38, 21))
+>A : Symbol(A, Decl(instanceofWithStructurallyIdenticalTypes.ts, 34, 1))
+
+class A2 { a: string }
+>A2 : Symbol(A2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 39, 22))
+>a : Symbol(A2.a, Decl(instanceofWithStructurallyIdenticalTypes.ts, 40, 10))
+
+class B extends A { b: string }
+>B : Symbol(B, Decl(instanceofWithStructurallyIdenticalTypes.ts, 40, 22))
+>A : Symbol(A, Decl(instanceofWithStructurallyIdenticalTypes.ts, 34, 1))
+>b : Symbol(B.b, Decl(instanceofWithStructurallyIdenticalTypes.ts, 41, 19))
+
+function goo(x: A) {
+>goo : Symbol(goo, Decl(instanceofWithStructurallyIdenticalTypes.ts, 41, 31))
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+>A : Symbol(A, Decl(instanceofWithStructurallyIdenticalTypes.ts, 34, 1))
+
+    if (x instanceof A) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+>A : Symbol(A, Decl(instanceofWithStructurallyIdenticalTypes.ts, 34, 1))
+
+        x;  // A
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    else {
+        x;  // never
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    if (x instanceof A1) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+>A1 : Symbol(A1, Decl(instanceofWithStructurallyIdenticalTypes.ts, 38, 21))
+
+        x;  // A1
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    else {
+        x;  // A
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    if (x instanceof A2) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+>A2 : Symbol(A2, Decl(instanceofWithStructurallyIdenticalTypes.ts, 39, 22))
+
+        x;  // A2
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    else {
+        x;  // A
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    if (x instanceof B) {
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+>B : Symbol(B, Decl(instanceofWithStructurallyIdenticalTypes.ts, 40, 22))
+
+        x;  // B
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+    else {
+        x;  // A
+>x : Symbol(x, Decl(instanceofWithStructurallyIdenticalTypes.ts, 43, 13))
+    }
+}
+
diff --git a/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.types b/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.types
new file mode 100644
index 0000000000000..d98a602579642
--- /dev/null
+++ b/tests/baselines/reference/instanceofWithStructurallyIdenticalTypes.types
@@ -0,0 +1,211 @@
+=== tests/cases/compiler/instanceofWithStructurallyIdenticalTypes.ts ===
+// Repro from #7271
+
+class C1 { item: string }
+>C1 : C1
+>item : string
+
+class C2 { item: string[] }
+>C2 : C2
+>item : string[]
+
+class C3 { item: string }
+>C3 : C3
+>item : string
+
+function foo1(x: C1 | C2 | C3): string {
+>foo1 : (x: C1 | C2 | C3) => string
+>x : C1 | C2 | C3
+>C1 : C1
+>C2 : C2
+>C3 : C3
+
+    if (x instanceof C1) {
+>x instanceof C1 : boolean
+>x : C1 | C2 | C3
+>C1 : typeof C1
+
+        return x.item;
+>x.item : string
+>x : C1
+>item : string
+    }
+    else if (x instanceof C2) {
+>x instanceof C2 : boolean
+>x : C2 | C3
+>C2 : typeof C2
+
+        return x.item[0];
+>x.item[0] : string
+>x.item : string[]
+>x : C2
+>item : string[]
+>0 : number
+    }
+    else if (x instanceof C3) {
+>x instanceof C3 : boolean
+>x : C3
+>C3 : typeof C3
+
+        return x.item;
+>x.item : string
+>x : C3
+>item : string
+    }
+    return "error";
+>"error" : string
+}
+
+function isC1(c: C1 | C2 | C3): c is C1 { return c instanceof C1 }
+>isC1 : (c: C1 | C2 | C3) => c is C1
+>c : C1 | C2 | C3
+>C1 : C1
+>C2 : C2
+>C3 : C3
+>c : any
+>C1 : C1
+>c instanceof C1 : boolean
+>c : C1 | C2 | C3
+>C1 : typeof C1
+
+function isC2(c: C1 | C2 | C3): c is C2 { return c instanceof C2 }
+>isC2 : (c: C1 | C2 | C3) => c is C2
+>c : C1 | C2 | C3
+>C1 : C1
+>C2 : C2
+>C3 : C3
+>c : any
+>C2 : C2
+>c instanceof C2 : boolean
+>c : C1 | C2 | C3
+>C2 : typeof C2
+
+function isC3(c: C1 | C2 | C3): c is C3 { return c instanceof C3 }
+>isC3 : (c: C1 | C2 | C3) => c is C3
+>c : C1 | C2 | C3
+>C1 : C1
+>C2 : C2
+>C3 : C3
+>c : any
+>C3 : C3
+>c instanceof C3 : boolean
+>c : C1 | C2 | C3
+>C3 : typeof C3
+
+function foo2(x: C1 | C2 | C3): string {
+>foo2 : (x: C1 | C2 | C3) => string
+>x : C1 | C2 | C3
+>C1 : C1
+>C2 : C2
+>C3 : C3
+
+    if (isC1(x)) {
+>isC1(x) : boolean
+>isC1 : (c: C1 | C2 | C3) => c is C1
+>x : C1 | C2 | C3
+
+        return x.item;
+>x.item : string
+>x : C1
+>item : string
+    }
+    else if (isC2(x)) {
+>isC2(x) : boolean
+>isC2 : (c: C1 | C2 | C3) => c is C2
+>x : C2 | C3
+
+        return x.item[0];
+>x.item[0] : string
+>x.item : string[]
+>x : C2
+>item : string[]
+>0 : number
+    }
+    else if (isC3(x)) {
+>isC3(x) : boolean
+>isC3 : (c: C1 | C2 | C3) => c is C3
+>x : C3
+
+        return x.item;
+>x.item : string
+>x : C3
+>item : string
+    }
+    return "error";
+>"error" : string
+}
+
+// More tests
+
+class A { a: string }
+>A : A
+>a : string
+
+class A1 extends A { }
+>A1 : A1
+>A : A
+
+class A2 { a: string }
+>A2 : A2
+>a : string
+
+class B extends A { b: string }
+>B : B
+>A : A
+>b : string
+
+function goo(x: A) {
+>goo : (x: A) => void
+>x : A
+>A : A
+
+    if (x instanceof A) {
+>x instanceof A : boolean
+>x : A
+>A : typeof A
+
+        x;  // A
+>x : A
+    }
+    else {
+        x;  // never
+>x : never
+    }
+    if (x instanceof A1) {
+>x instanceof A1 : boolean
+>x : A
+>A1 : typeof A1
+
+        x;  // A1
+>x : A1
+    }
+    else {
+        x;  // A
+>x : A
+    }
+    if (x instanceof A2) {
+>x instanceof A2 : boolean
+>x : A
+>A2 : typeof A2
+
+        x;  // A2
+>x : A2
+    }
+    else {
+        x;  // A
+>x : A
+    }
+    if (x instanceof B) {
+>x instanceof B : boolean
+>x : A
+>B : typeof B
+
+        x;  // B
+>x : B
+    }
+    else {
+        x;  // A
+>x : A
+    }
+}
+
diff --git a/tests/baselines/reference/instantiateContextuallyTypedGenericThis.js b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.js
new file mode 100644
index 0000000000000..176df15985f3a
--- /dev/null
+++ b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.js
@@ -0,0 +1,20 @@
+//// [instantiateContextuallyTypedGenericThis.ts]
+interface JQuery {
+    each<T>(
+        collection: T[], callback: (this: T, dit: T) => T
+    ): T[];
+}
+
+let $: JQuery;
+let lines: string[];
+$.each(lines, function(dit) {
+    return dit.charAt(0) + this.charAt(1);
+});
+
+
+//// [instantiateContextuallyTypedGenericThis.js]
+var $;
+var lines;
+$.each(lines, function (dit) {
+    return dit.charAt(0) + this.charAt(1);
+});
diff --git a/tests/baselines/reference/instantiateContextuallyTypedGenericThis.symbols b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.symbols
new file mode 100644
index 0000000000000..1db5b30dd0b30
--- /dev/null
+++ b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.symbols
@@ -0,0 +1,46 @@
+=== tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts ===
+interface JQuery {
+>JQuery : Symbol(JQuery, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 0))
+
+    each<T>(
+>each : Symbol(JQuery.each, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 18))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+
+        collection: T[], callback: (this: T, dit: T) => T
+>collection : Symbol(collection, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 12))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+>callback : Symbol(callback, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 24))
+>this : Symbol(this, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 36))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+>dit : Symbol(dit, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 44))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+
+    ): T[];
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+}
+
+let $: JQuery;
+>$ : Symbol($, Decl(instantiateContextuallyTypedGenericThis.ts, 6, 3))
+>JQuery : Symbol(JQuery, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 0))
+
+let lines: string[];
+>lines : Symbol(lines, Decl(instantiateContextuallyTypedGenericThis.ts, 7, 3))
+
+$.each(lines, function(dit) {
+>$.each : Symbol(JQuery.each, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 18))
+>$ : Symbol($, Decl(instantiateContextuallyTypedGenericThis.ts, 6, 3))
+>each : Symbol(JQuery.each, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 18))
+>lines : Symbol(lines, Decl(instantiateContextuallyTypedGenericThis.ts, 7, 3))
+>dit : Symbol(dit, Decl(instantiateContextuallyTypedGenericThis.ts, 8, 23))
+
+    return dit.charAt(0) + this.charAt(1);
+>dit.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>dit : Symbol(dit, Decl(instantiateContextuallyTypedGenericThis.ts, 8, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>this.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>this : Symbol(this, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 36))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+
+});
+
diff --git a/tests/baselines/reference/instantiateContextuallyTypedGenericThis.types b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.types
new file mode 100644
index 0000000000000..5cdce6b99fe18
--- /dev/null
+++ b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.types
@@ -0,0 +1,53 @@
+=== tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts ===
+interface JQuery {
+>JQuery : JQuery
+
+    each<T>(
+>each : <T>(collection: T[], callback: (this: T, dit: T) => T) => T[]
+>T : T
+
+        collection: T[], callback: (this: T, dit: T) => T
+>collection : T[]
+>T : T
+>callback : (this: T, dit: T) => T
+>this : T
+>T : T
+>dit : T
+>T : T
+>T : T
+
+    ): T[];
+>T : T
+}
+
+let $: JQuery;
+>$ : JQuery
+>JQuery : JQuery
+
+let lines: string[];
+>lines : string[]
+
+$.each(lines, function(dit) {
+>$.each(lines, function(dit) {    return dit.charAt(0) + this.charAt(1);}) : string[]
+>$.each : <T>(collection: T[], callback: (this: T, dit: T) => T) => T[]
+>$ : JQuery
+>each : <T>(collection: T[], callback: (this: T, dit: T) => T) => T[]
+>lines : string[]
+>function(dit) {    return dit.charAt(0) + this.charAt(1);} : (this: string, dit: string) => string
+>dit : string
+
+    return dit.charAt(0) + this.charAt(1);
+>dit.charAt(0) + this.charAt(1) : string
+>dit.charAt(0) : string
+>dit.charAt : (pos: number) => string
+>dit : string
+>charAt : (pos: number) => string
+>0 : number
+>this.charAt(1) : string
+>this.charAt : (pos: number) => string
+>this : string
+>charAt : (pos: number) => string
+>1 : number
+
+});
+
diff --git a/tests/baselines/reference/iterableArrayPattern29.errors.txt b/tests/baselines/reference/iterableArrayPattern29.errors.txt
index b34d0317d5768..29e5d0d2a3f98 100644
--- a/tests/baselines/reference/iterableArrayPattern29.errors.txt
+++ b/tests/baselines/reference/iterableArrayPattern29.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(1,33): error TS2501: A rest element cannot contain a binding pattern.
 tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(2,21): error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'.
-  Types of property '1' are incompatible.
-    Type 'boolean' is not assignable to type 'number'.
+  Type 'boolean' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts (2 errors) ====
@@ -11,5 +10,4 @@ tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(2,21): error
     takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'.
-!!! error TS2345:   Types of property '1' are incompatible.
-!!! error TS2345:     Type 'boolean' is not assignable to type 'number'.
\ No newline at end of file
+!!! error TS2345:   Type 'boolean' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/jsdocLiteral.js b/tests/baselines/reference/jsdocLiteral.js
new file mode 100644
index 0000000000000..1a017160302c9
--- /dev/null
+++ b/tests/baselines/reference/jsdocLiteral.js
@@ -0,0 +1,24 @@
+//// [in.js]
+/**
+ * @param {'literal'} p1
+ * @param {"literal"} p2
+ * @param {'literal' | 'other'} p3
+ * @param {'literal' | number} p4
+ * @param {12 | true | 'str'} p5
+ */
+function f(p1, p2, p3, p4, p5) {
+    return p1 + p2 + p3 + p4 + p5 + '.';
+}
+
+
+//// [out.js]
+/**
+ * @param {'literal'} p1
+ * @param {"literal"} p2
+ * @param {'literal' | 'other'} p3
+ * @param {'literal' | number} p4
+ * @param {12 | true | 'str'} p5
+ */
+function f(p1, p2, p3, p4, p5) {
+    return p1 + p2 + p3 + p4 + p5 + '.';
+}
diff --git a/tests/baselines/reference/jsdocLiteral.symbols b/tests/baselines/reference/jsdocLiteral.symbols
new file mode 100644
index 0000000000000..9f01fe782aa62
--- /dev/null
+++ b/tests/baselines/reference/jsdocLiteral.symbols
@@ -0,0 +1,24 @@
+=== tests/cases/conformance/jsdoc/in.js ===
+/**
+ * @param {'literal'} p1
+ * @param {"literal"} p2
+ * @param {'literal' | 'other'} p3
+ * @param {'literal' | number} p4
+ * @param {12 | true | 'str'} p5
+ */
+function f(p1, p2, p3, p4, p5) {
+>f : Symbol(f, Decl(in.js, 0, 0))
+>p1 : Symbol(p1, Decl(in.js, 7, 11))
+>p2 : Symbol(p2, Decl(in.js, 7, 14))
+>p3 : Symbol(p3, Decl(in.js, 7, 18))
+>p4 : Symbol(p4, Decl(in.js, 7, 22))
+>p5 : Symbol(p5, Decl(in.js, 7, 26))
+
+    return p1 + p2 + p3 + p4 + p5 + '.';
+>p1 : Symbol(p1, Decl(in.js, 7, 11))
+>p2 : Symbol(p2, Decl(in.js, 7, 14))
+>p3 : Symbol(p3, Decl(in.js, 7, 18))
+>p4 : Symbol(p4, Decl(in.js, 7, 22))
+>p5 : Symbol(p5, Decl(in.js, 7, 26))
+}
+
diff --git a/tests/baselines/reference/jsdocLiteral.types b/tests/baselines/reference/jsdocLiteral.types
new file mode 100644
index 0000000000000..b6c9e522ac35c
--- /dev/null
+++ b/tests/baselines/reference/jsdocLiteral.types
@@ -0,0 +1,30 @@
+=== tests/cases/conformance/jsdoc/in.js ===
+/**
+ * @param {'literal'} p1
+ * @param {"literal"} p2
+ * @param {'literal' | 'other'} p3
+ * @param {'literal' | number} p4
+ * @param {12 | true | 'str'} p5
+ */
+function f(p1, p2, p3, p4, p5) {
+>f : (p1: "literal", p2: "literal", p3: "literal" | "other", p4: number | "literal", p5: true | 12 | "str") => string
+>p1 : "literal"
+>p2 : "literal"
+>p3 : "literal" | "other"
+>p4 : number | "literal"
+>p5 : true | 12 | "str"
+
+    return p1 + p2 + p3 + p4 + p5 + '.';
+>p1 + p2 + p3 + p4 + p5 + '.' : string
+>p1 + p2 + p3 + p4 + p5 : string
+>p1 + p2 + p3 + p4 : string
+>p1 + p2 + p3 : string
+>p1 + p2 : string
+>p1 : "literal"
+>p2 : "literal"
+>p3 : "literal" | "other"
+>p4 : number | "literal"
+>p5 : true | 12 | "str"
+>'.' : string
+}
+
diff --git a/tests/baselines/reference/jsdocNeverUndefinedNull.js b/tests/baselines/reference/jsdocNeverUndefinedNull.js
new file mode 100644
index 0000000000000..e57b7091a3bea
--- /dev/null
+++ b/tests/baselines/reference/jsdocNeverUndefinedNull.js
@@ -0,0 +1,20 @@
+//// [in.js]
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+}
+
+
+//// [out.js]
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+}
diff --git a/tests/baselines/reference/jsdocNeverUndefinedNull.symbols b/tests/baselines/reference/jsdocNeverUndefinedNull.symbols
new file mode 100644
index 0000000000000..a57636ed34402
--- /dev/null
+++ b/tests/baselines/reference/jsdocNeverUndefinedNull.symbols
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/jsdoc/in.js ===
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+>f : Symbol(f, Decl(in.js, 0, 0))
+>p1 : Symbol(p1, Decl(in.js, 6, 11))
+>p2 : Symbol(p2, Decl(in.js, 6, 14))
+>p3 : Symbol(p3, Decl(in.js, 6, 18))
+}
+
diff --git a/tests/baselines/reference/jsdocNeverUndefinedNull.types b/tests/baselines/reference/jsdocNeverUndefinedNull.types
new file mode 100644
index 0000000000000..fe57cc298e2cb
--- /dev/null
+++ b/tests/baselines/reference/jsdocNeverUndefinedNull.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/jsdoc/in.js ===
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+>f : (p1: never, p2: undefined, p3: null) => void
+>p1 : never
+>p2 : undefined
+>p3 : null
+}
+
diff --git a/tests/baselines/reference/library-reference-5.errors.txt b/tests/baselines/reference/library-reference-5.errors.txt
index a3729bc3a9953..c23b49c61de89 100644
--- a/tests/baselines/reference/library-reference-5.errors.txt
+++ b/tests/baselines/reference/library-reference-5.errors.txt
@@ -1,4 +1,4 @@
-/node_modules/bar/index.d.ts(1,1): message TS4090: Conflicting library definitions for 'alpha' found at '/node_modules/bar/node_modules/alpha/index.d.ts' and '/node_modules/foo/node_modules/alpha/index.d.ts'. Copy the correct file to the 'typings' folder to resolve this conflict.
+/node_modules/bar/index.d.ts(1,1): message TS4090: Conflicting definitions for 'alpha' found at '/node_modules/bar/node_modules/alpha/index.d.ts' and '/node_modules/foo/node_modules/alpha/index.d.ts'. Consider installing a specific version of this library to resolve the conflict.
 
 
 ==== /src/root.ts (0 errors) ====
@@ -18,7 +18,7 @@
 ==== /node_modules/bar/index.d.ts (1 errors) ====
     /// <reference types="alpha" />
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! message TS4090: Conflicting library definitions for 'alpha' found at '/node_modules/bar/node_modules/alpha/index.d.ts' and '/node_modules/foo/node_modules/alpha/index.d.ts'. Copy the correct file to the 'typings' folder to resolve this conflict.
+!!! message TS4090: Conflicting definitions for 'alpha' found at '/node_modules/bar/node_modules/alpha/index.d.ts' and '/node_modules/foo/node_modules/alpha/index.d.ts'. Consider installing a specific version of this library to resolve the conflict.
     declare var bar: any;
     
 ==== /node_modules/bar/node_modules/alpha/index.d.ts (0 errors) ====
diff --git a/tests/baselines/reference/missingFunctionImplementation2.errors.txt b/tests/baselines/reference/missingFunctionImplementation2.errors.txt
index a695482e1fba3..86d8baba6f780 100644
--- a/tests/baselines/reference/missingFunctionImplementation2.errors.txt
+++ b/tests/baselines/reference/missingFunctionImplementation2.errors.txt
@@ -4,7 +4,7 @@ tests/cases/compiler/missingFunctionImplementation2_b.ts(1,17): error TS2391: Fu
 
 ==== tests/cases/compiler/missingFunctionImplementation2_a.ts (1 errors) ====
     export {};
-    declare module "./missingFunctionImplementation2_b.ts" {
+    declare module "./missingFunctionImplementation2_b" {
       export function f(a, b): void;
                       ~
 !!! error TS2384: Overload signatures must all be ambient or non-ambient.
diff --git a/tests/baselines/reference/missingFunctionImplementation2.js b/tests/baselines/reference/missingFunctionImplementation2.js
index 104b6dd9443d6..7b3456015c832 100644
--- a/tests/baselines/reference/missingFunctionImplementation2.js
+++ b/tests/baselines/reference/missingFunctionImplementation2.js
@@ -2,7 +2,7 @@
 
 //// [missingFunctionImplementation2_a.ts]
 export {};
-declare module "./missingFunctionImplementation2_b.ts" {
+declare module "./missingFunctionImplementation2_b" {
   export function f(a, b): void;
 }
 
diff --git a/tests/baselines/reference/moduleResolutionNoTs.errors.txt b/tests/baselines/reference/moduleResolutionNoTs.errors.txt
new file mode 100644
index 0000000000000..c054330731158
--- /dev/null
+++ b/tests/baselines/reference/moduleResolutionNoTs.errors.txt
@@ -0,0 +1,31 @@
+tests/cases/compiler/user.ts(1,15): error TS2691: An import path cannot end with a '.ts' extension. Consider importing './x' instead.
+tests/cases/compiler/user.ts(2,15): error TS2691: An import path cannot end with a '.tsx' extension. Consider importing './y' instead.
+tests/cases/compiler/user.ts(3,15): error TS2691: An import path cannot end with a '.d.ts' extension. Consider importing './z' instead.
+
+
+==== tests/cases/compiler/x.ts (0 errors) ====
+    export default 0;
+    
+==== tests/cases/compiler/y.tsx (0 errors) ====
+    export default 0;
+    
+==== tests/cases/compiler/z.d.ts (0 errors) ====
+    declare const x: number;
+    export default x;
+    
+==== tests/cases/compiler/user.ts (3 errors) ====
+    import x from "./x.ts";
+                  ~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.ts' extension. Consider importing './x' instead.
+    import y from "./y.tsx";
+                  ~~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.tsx' extension. Consider importing './y' instead.
+    import z from "./z.d.ts";
+                  ~~~~~~~~~~
+!!! error TS2691: An import path cannot end with a '.d.ts' extension. Consider importing './z' instead.
+    
+    // Making sure the suggested fixes are valid:
+    import x2 from "./x";
+    import y2 from "./y";
+    import z2 from "./z";
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/moduleResolutionNoTs.js b/tests/baselines/reference/moduleResolutionNoTs.js
new file mode 100644
index 0000000000000..9ff33d688ea24
--- /dev/null
+++ b/tests/baselines/reference/moduleResolutionNoTs.js
@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/moduleResolutionNoTs.ts] ////
+
+//// [x.ts]
+export default 0;
+
+//// [y.tsx]
+export default 0;
+
+//// [z.d.ts]
+declare const x: number;
+export default x;
+
+//// [user.ts]
+import x from "./x.ts";
+import y from "./y.tsx";
+import z from "./z.d.ts";
+
+// Making sure the suggested fixes are valid:
+import x2 from "./x";
+import y2 from "./y";
+import z2 from "./z";
+
+
+//// [x.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = 0;
+//// [y.js]
+"use strict";
+exports.__esModule = true;
+exports["default"] = 0;
+//// [user.js]
+"use strict";
diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.js b/tests/baselines/reference/moduleResolutionWithExtensions.js
index df12a3531bcfa..16d176872cac1 100644
--- a/tests/baselines/reference/moduleResolutionWithExtensions.js
+++ b/tests/baselines/reference/moduleResolutionWithExtensions.js
@@ -8,10 +8,6 @@ export default 0;
 //// [b.ts]
 import a from './a';
 
-// Matching extension
-//// [c.ts]
-import a from './a.ts';
-
 // '.js' extension: stripped and replaced with '.ts'
 //// [d.ts]
 import a from './a.js';
@@ -36,9 +32,6 @@ exports["default"] = 0;
 // No extension: '.ts' added 
 //// [b.js]
 "use strict";
-// Matching extension 
-//// [c.js]
-"use strict";
 // '.js' extension: stripped and replaced with '.ts' 
 //// [d.js]
 "use strict";
diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.symbols b/tests/baselines/reference/moduleResolutionWithExtensions.symbols
index e9934946a64fd..eaaa1d51cc097 100644
--- a/tests/baselines/reference/moduleResolutionWithExtensions.symbols
+++ b/tests/baselines/reference/moduleResolutionWithExtensions.symbols
@@ -7,11 +7,6 @@ No type information for this code.=== /src/b.ts ===
 import a from './a';
 >a : Symbol(a, Decl(b.ts, 0, 6))
 
-// Matching extension
-=== /src/c.ts ===
-import a from './a.ts';
->a : Symbol(a, Decl(c.ts, 0, 6))
-
 // '.js' extension: stripped and replaced with '.ts'
 === /src/d.ts ===
 import a from './a.js';
diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.trace.json b/tests/baselines/reference/moduleResolutionWithExtensions.trace.json
index 7dc9e8c104b8c..5060006ac56bd 100644
--- a/tests/baselines/reference/moduleResolutionWithExtensions.trace.json
+++ b/tests/baselines/reference/moduleResolutionWithExtensions.trace.json
@@ -5,12 +5,6 @@
     "File '/src/a.ts' exist - use it as a name resolution result.",
     "Resolving real path for '/src/a.ts', result '/src/a.ts'",
     "======== Module name './a' was successfully resolved to '/src/a.ts'. ========",
-    "======== Resolving module './a.ts' from '/src/c.ts'. ========",
-    "Module resolution kind is not specified, using 'NodeJs'.",
-    "Loading module as file / folder, candidate module location '/src/a.ts'.",
-    "File '/src/a.ts' exist - use it as a name resolution result.",
-    "Resolving real path for '/src/a.ts', result '/src/a.ts'",
-    "======== Module name './a.ts' was successfully resolved to '/src/a.ts'. ========",
     "======== Resolving module './a.js' from '/src/d.ts'. ========",
     "Module resolution kind is not specified, using 'NodeJs'.",
     "Loading module as file / folder, candidate module location '/src/a.js'.",
diff --git a/tests/baselines/reference/moduleResolutionWithExtensions.types b/tests/baselines/reference/moduleResolutionWithExtensions.types
index fbc0091ee3b95..f59eda1a81e79 100644
--- a/tests/baselines/reference/moduleResolutionWithExtensions.types
+++ b/tests/baselines/reference/moduleResolutionWithExtensions.types
@@ -7,11 +7,6 @@ No type information for this code.=== /src/b.ts ===
 import a from './a';
 >a : number
 
-// Matching extension
-=== /src/c.ts ===
-import a from './a.ts';
->a : number
-
 // '.js' extension: stripped and replaced with '.ts'
 === /src/d.ts ===
 import a from './a.js';
diff --git a/tests/baselines/reference/multipleDeclarations.js b/tests/baselines/reference/multipleDeclarations.js
index 5f5ac29e90964..7fb7e0bca026f 100644
--- a/tests/baselines/reference/multipleDeclarations.js
+++ b/tests/baselines/reference/multipleDeclarations.js
@@ -1,11 +1,38 @@
 //// [input.js]
-
 function C() {
     this.m = null;
 }
 C.prototype.m = function() {
     this.nothing();
-};
+}
+class X {
+    constructor() {
+        this.m = this.m.bind(this);
+        this.mistake = 'frankly, complete nonsense';
+    }
+    m() {
+    }
+    mistake() {
+    }
+}
+let x = new X();
+X.prototype.mistake = false;
+x.m();
+x.mistake;
+class Y {
+    mistake() {
+    }
+    m() {
+    }
+    constructor() {
+        this.m = this.m.bind(this);
+        this.mistake = 'even more nonsense';
+    }
+}
+Y.prototype.mistake = true;
+let y = new Y();
+y.m();
+y.mistake();
 
 
 //// [output.js]
@@ -15,3 +42,33 @@ function C() {
 C.prototype.m = function () {
     this.nothing();
 };
+var X = (function () {
+    function X() {
+        this.m = this.m.bind(this);
+        this.mistake = 'frankly, complete nonsense';
+    }
+    X.prototype.m = function () {
+    };
+    X.prototype.mistake = function () {
+    };
+    return X;
+}());
+var x = new X();
+X.prototype.mistake = false;
+x.m();
+x.mistake;
+var Y = (function () {
+    function Y() {
+        this.m = this.m.bind(this);
+        this.mistake = 'even more nonsense';
+    }
+    Y.prototype.mistake = function () {
+    };
+    Y.prototype.m = function () {
+    };
+    return Y;
+}());
+Y.prototype.mistake = true;
+var y = new Y();
+y.m();
+y.mistake();
diff --git a/tests/baselines/reference/multipleDeclarations.symbols b/tests/baselines/reference/multipleDeclarations.symbols
index a256943dd506c..9e49c2fc00cc4 100644
--- a/tests/baselines/reference/multipleDeclarations.symbols
+++ b/tests/baselines/reference/multipleDeclarations.symbols
@@ -1,19 +1,106 @@
 === tests/cases/conformance/salsa/input.js ===
-
 function C() {
 >C : Symbol(C, Decl(input.js, 0, 0))
 
     this.m = null;
->m : Symbol(C.m, Decl(input.js, 1, 14), Decl(input.js, 3, 1))
+>m : Symbol(C.m, Decl(input.js, 0, 14), Decl(input.js, 2, 1))
 }
 C.prototype.m = function() {
->C.prototype : Symbol(C.m, Decl(input.js, 1, 14), Decl(input.js, 3, 1))
+>C.prototype : Symbol(C.m, Decl(input.js, 0, 14), Decl(input.js, 2, 1))
 >C : Symbol(C, Decl(input.js, 0, 0))
 >prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --))
->m : Symbol(C.m, Decl(input.js, 1, 14), Decl(input.js, 3, 1))
+>m : Symbol(C.m, Decl(input.js, 0, 14), Decl(input.js, 2, 1))
 
     this.nothing();
 >this : Symbol(C, Decl(input.js, 0, 0))
+}
+class X {
+>X : Symbol(X, Decl(input.js, 5, 1))
+
+    constructor() {
+        this.m = this.m.bind(this);
+>this.m : Symbol(X.m, Decl(input.js, 10, 5))
+>this : Symbol(X, Decl(input.js, 5, 1))
+>m : Symbol(X.m, Decl(input.js, 7, 19))
+>this.m.bind : Symbol(Function.bind, Decl(lib.d.ts, --, --))
+>this.m : Symbol(X.m, Decl(input.js, 10, 5))
+>this : Symbol(X, Decl(input.js, 5, 1))
+>m : Symbol(X.m, Decl(input.js, 10, 5))
+>bind : Symbol(Function.bind, Decl(lib.d.ts, --, --))
+>this : Symbol(X, Decl(input.js, 5, 1))
+
+        this.mistake = 'frankly, complete nonsense';
+>this.mistake : Symbol(X.mistake, Decl(input.js, 12, 5))
+>this : Symbol(X, Decl(input.js, 5, 1))
+>mistake : Symbol(X.mistake, Decl(input.js, 8, 35))
+    }
+    m() {
+>m : Symbol(X.m, Decl(input.js, 10, 5))
+    }
+    mistake() {
+>mistake : Symbol(X.mistake, Decl(input.js, 12, 5))
+    }
+}
+let x = new X();
+>x : Symbol(x, Decl(input.js, 16, 3))
+>X : Symbol(X, Decl(input.js, 5, 1))
+
+X.prototype.mistake = false;
+>X.prototype.mistake : Symbol(X.mistake, Decl(input.js, 12, 5))
+>X : Symbol(X, Decl(input.js, 5, 1))
+>prototype : Symbol(X.prototype)
+
+x.m();
+>x.m : Symbol(X.m, Decl(input.js, 10, 5))
+>x : Symbol(x, Decl(input.js, 16, 3))
+>m : Symbol(X.m, Decl(input.js, 10, 5))
+
+x.mistake;
+>x.mistake : Symbol(X.mistake, Decl(input.js, 12, 5))
+>x : Symbol(x, Decl(input.js, 16, 3))
+>mistake : Symbol(X.mistake, Decl(input.js, 12, 5))
+
+class Y {
+>Y : Symbol(Y, Decl(input.js, 19, 10))
+
+    mistake() {
+>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35))
+    }
+    m() {
+>m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
+    }
+    constructor() {
+        this.m = this.m.bind(this);
+>this.m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
+>this : Symbol(Y, Decl(input.js, 19, 10))
+>m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
+>this.m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
+>this : Symbol(Y, Decl(input.js, 19, 10))
+>m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
+>this : Symbol(Y, Decl(input.js, 19, 10))
+
+        this.mistake = 'even more nonsense';
+>this.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35))
+>this : Symbol(Y, Decl(input.js, 19, 10))
+>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35))
+    }
+}
+Y.prototype.mistake = true;
+>Y.prototype.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35))
+>Y : Symbol(Y, Decl(input.js, 19, 10))
+>prototype : Symbol(Y.prototype)
+
+let y = new Y();
+>y : Symbol(y, Decl(input.js, 31, 3))
+>Y : Symbol(Y, Decl(input.js, 19, 10))
+
+y.m();
+>y.m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
+>y : Symbol(y, Decl(input.js, 31, 3))
+>m : Symbol(Y.m, Decl(input.js, 22, 5), Decl(input.js, 25, 19))
 
-};
+y.mistake();
+>y.mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35))
+>y : Symbol(y, Decl(input.js, 31, 3))
+>mistake : Symbol(Y.mistake, Decl(input.js, 20, 9), Decl(input.js, 26, 35))
 
diff --git a/tests/baselines/reference/multipleDeclarations.types b/tests/baselines/reference/multipleDeclarations.types
index 7c0a3de70c9c6..900d03195d486 100644
--- a/tests/baselines/reference/multipleDeclarations.types
+++ b/tests/baselines/reference/multipleDeclarations.types
@@ -1,5 +1,4 @@
 === tests/cases/conformance/salsa/input.js ===
-
 function C() {
 >C : () => void
 
@@ -24,6 +23,117 @@ C.prototype.m = function() {
 >this.nothing : any
 >this : { m: () => void; }
 >nothing : any
+}
+class X {
+>X : X
+
+    constructor() {
+        this.m = this.m.bind(this);
+>this.m = this.m.bind(this) : any
+>this.m : () => void
+>this : this
+>m : () => void
+>this.m.bind(this) : any
+>this.m.bind : (this: Function, thisArg: any, ...argArray: any[]) => any
+>this.m : () => void
+>this : this
+>m : () => void
+>bind : (this: Function, thisArg: any, ...argArray: any[]) => any
+>this : this
+
+        this.mistake = 'frankly, complete nonsense';
+>this.mistake = 'frankly, complete nonsense' : string
+>this.mistake : () => void
+>this : this
+>mistake : () => void
+>'frankly, complete nonsense' : string
+    }
+    m() {
+>m : () => void
+    }
+    mistake() {
+>mistake : () => void
+    }
+}
+let x = new X();
+>x : X
+>new X() : X
+>X : typeof X
+
+X.prototype.mistake = false;
+>X.prototype.mistake = false : boolean
+>X.prototype.mistake : () => void
+>X.prototype : X
+>X : typeof X
+>prototype : X
+>mistake : () => void
+>false : boolean
+
+x.m();
+>x.m() : void
+>x.m : () => void
+>x : X
+>m : () => void
+
+x.mistake;
+>x.mistake : () => void
+>x : X
+>mistake : () => void
+
+class Y {
+>Y : Y
+
+    mistake() {
+>mistake : any
+    }
+    m() {
+>m : any
+    }
+    constructor() {
+        this.m = this.m.bind(this);
+>this.m = this.m.bind(this) : any
+>this.m : any
+>this : this
+>m : any
+>this.m.bind(this) : any
+>this.m.bind : any
+>this.m : any
+>this : this
+>m : any
+>bind : any
+>this : this
+
+        this.mistake = 'even more nonsense';
+>this.mistake = 'even more nonsense' : string
+>this.mistake : any
+>this : this
+>mistake : any
+>'even more nonsense' : string
+    }
+}
+Y.prototype.mistake = true;
+>Y.prototype.mistake = true : boolean
+>Y.prototype.mistake : any
+>Y.prototype : Y
+>Y : typeof Y
+>prototype : Y
+>mistake : any
+>true : boolean
+
+let y = new Y();
+>y : Y
+>new Y() : Y
+>Y : typeof Y
+
+y.m();
+>y.m() : any
+>y.m : any
+>y : Y
+>m : any
 
-};
+y.mistake();
+>y.mistake() : any
+>y.mistake : any
+>y : Y
+>mistake : any
 
diff --git a/tests/baselines/reference/narrowExceptionVariableInCatchClause.errors.txt b/tests/baselines/reference/narrowExceptionVariableInCatchClause.errors.txt
new file mode 100644
index 0000000000000..e435b98050de6
--- /dev/null
+++ b/tests/baselines/reference/narrowExceptionVariableInCatchClause.errors.txt
@@ -0,0 +1,33 @@
+tests/cases/conformance/types/any/narrowExceptionVariableInCatchClause.ts(11,17): error TS2339: Property 'doPanic' does not exist on type '{ type: "foo"; dontPanic(): any; }'.
+tests/cases/conformance/types/any/narrowExceptionVariableInCatchClause.ts(16,17): error TS2339: Property 'massage' does not exist on type 'Error'.
+
+
+==== tests/cases/conformance/types/any/narrowExceptionVariableInCatchClause.ts (2 errors) ====
+    declare function isFooError(x: any): x is { type: 'foo'; dontPanic(); };
+    
+    function tryCatch() {
+        try {
+            // do stuff...
+        }
+        catch (err) { // err is implicitly 'any' and cannot be annotated
+    
+            if (isFooError(err)) {
+                err.dontPanic(); // OK
+                err.doPanic(); // ERROR: Property 'doPanic' does not exist on type '{...}'
+                    ~~~~~~~
+!!! error TS2339: Property 'doPanic' does not exist on type '{ type: "foo"; dontPanic(): any; }'.
+            }
+    
+            else if (err instanceof Error) {
+                err.message;
+                err.massage; // ERROR: Property 'massage' does not exist on type 'Error'
+                    ~~~~~~~
+!!! error TS2339: Property 'massage' does not exist on type 'Error'.
+            }
+    
+            else {
+                throw err;
+            }
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/narrowExceptionVariableInCatchClause.js b/tests/baselines/reference/narrowExceptionVariableInCatchClause.js
new file mode 100644
index 0000000000000..5808ed7682683
--- /dev/null
+++ b/tests/baselines/reference/narrowExceptionVariableInCatchClause.js
@@ -0,0 +1,44 @@
+//// [narrowExceptionVariableInCatchClause.ts]
+declare function isFooError(x: any): x is { type: 'foo'; dontPanic(); };
+
+function tryCatch() {
+    try {
+        // do stuff...
+    }
+    catch (err) { // err is implicitly 'any' and cannot be annotated
+
+        if (isFooError(err)) {
+            err.dontPanic(); // OK
+            err.doPanic(); // ERROR: Property 'doPanic' does not exist on type '{...}'
+        }
+
+        else if (err instanceof Error) {
+            err.message;
+            err.massage; // ERROR: Property 'massage' does not exist on type 'Error'
+        }
+
+        else {
+            throw err;
+        }
+    }
+}
+
+
+//// [narrowExceptionVariableInCatchClause.js]
+function tryCatch() {
+    try {
+    }
+    catch (err) {
+        if (isFooError(err)) {
+            err.dontPanic(); // OK
+            err.doPanic(); // ERROR: Property 'doPanic' does not exist on type '{...}'
+        }
+        else if (err instanceof Error) {
+            err.message;
+            err.massage; // ERROR: Property 'massage' does not exist on type 'Error'
+        }
+        else {
+            throw err;
+        }
+    }
+}
diff --git a/tests/baselines/reference/narrowFromAnyWithInstanceof.errors.txt b/tests/baselines/reference/narrowFromAnyWithInstanceof.errors.txt
new file mode 100644
index 0000000000000..3e152b0faf456
--- /dev/null
+++ b/tests/baselines/reference/narrowFromAnyWithInstanceof.errors.txt
@@ -0,0 +1,33 @@
+tests/cases/conformance/types/any/narrowFromAnyWithInstanceof.ts(17,7): error TS2339: Property 'mesage' does not exist on type 'Error'.
+tests/cases/conformance/types/any/narrowFromAnyWithInstanceof.ts(22,7): error TS2339: Property 'getHuors' does not exist on type 'Date'.
+
+
+==== tests/cases/conformance/types/any/narrowFromAnyWithInstanceof.ts (2 errors) ====
+    declare var x: any;
+    
+    if (x instanceof Function) { // 'any' is not narrowed when target type is 'Function'
+        x();
+        x(1, 2, 3);
+        x("hello!");
+        x.prop;
+    }
+    
+    if (x instanceof Object) { // 'any' is not narrowed when target type is 'Object'
+        x.method();
+        x();
+    }
+    
+    if (x instanceof Error) { // 'any' is narrowed to types other than 'Function'/'Object'
+        x.message;
+        x.mesage;
+          ~~~~~~
+!!! error TS2339: Property 'mesage' does not exist on type 'Error'.
+    }
+    
+    if (x instanceof Date) {
+        x.getDate();
+        x.getHuors();
+          ~~~~~~~~
+!!! error TS2339: Property 'getHuors' does not exist on type 'Date'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/narrowFromAnyWithInstanceof.js b/tests/baselines/reference/narrowFromAnyWithInstanceof.js
new file mode 100644
index 0000000000000..4cf1ca174aa02
--- /dev/null
+++ b/tests/baselines/reference/narrowFromAnyWithInstanceof.js
@@ -0,0 +1,45 @@
+//// [narrowFromAnyWithInstanceof.ts]
+declare var x: any;
+
+if (x instanceof Function) { // 'any' is not narrowed when target type is 'Function'
+    x();
+    x(1, 2, 3);
+    x("hello!");
+    x.prop;
+}
+
+if (x instanceof Object) { // 'any' is not narrowed when target type is 'Object'
+    x.method();
+    x();
+}
+
+if (x instanceof Error) { // 'any' is narrowed to types other than 'Function'/'Object'
+    x.message;
+    x.mesage;
+}
+
+if (x instanceof Date) {
+    x.getDate();
+    x.getHuors();
+}
+
+
+//// [narrowFromAnyWithInstanceof.js]
+if (x instanceof Function) {
+    x();
+    x(1, 2, 3);
+    x("hello!");
+    x.prop;
+}
+if (x instanceof Object) {
+    x.method();
+    x();
+}
+if (x instanceof Error) {
+    x.message;
+    x.mesage;
+}
+if (x instanceof Date) {
+    x.getDate();
+    x.getHuors();
+}
diff --git a/tests/baselines/reference/narrowFromAnyWithTypePredicate.errors.txt b/tests/baselines/reference/narrowFromAnyWithTypePredicate.errors.txt
new file mode 100644
index 0000000000000..94f41becdade8
--- /dev/null
+++ b/tests/baselines/reference/narrowFromAnyWithTypePredicate.errors.txt
@@ -0,0 +1,50 @@
+tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts(22,7): error TS2339: Property 'method' does not exist on type '{}'.
+tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts(23,5): error TS2349: Cannot invoke an expression whose type lacks a call signature.
+tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts(28,7): error TS2339: Property 'mesage' does not exist on type 'Error'.
+tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts(33,7): error TS2339: Property 'getHuors' does not exist on type 'Date'.
+
+
+==== tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts (4 errors) ====
+    declare var x: any;
+    declare function isFunction(x): x is Function;
+    declare function isObject(x): x is Object;
+    declare function isAnything(x): x is {};
+    declare function isError(x): x is Error;
+    declare function isDate(x): x is Date;
+    
+    
+    if (isFunction(x)) { // 'any' is not narrowed when target type is 'Function'
+        x();
+        x(1, 2, 3);
+        x("hello!");
+        x.prop;
+    }
+    
+    if (isObject(x)) { // 'any' is not narrowed when target type is 'Object'
+        x.method();
+        x();
+    }
+    
+    if (isAnything(x)) { // 'any' is narrowed to types other than 'Function'/'Object' (including {})
+        x.method();
+          ~~~~~~
+!!! error TS2339: Property 'method' does not exist on type '{}'.
+        x();
+        ~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
+    }
+    
+    if (isError(x)) { 
+        x.message;
+        x.mesage;
+          ~~~~~~
+!!! error TS2339: Property 'mesage' does not exist on type 'Error'.
+    }
+    
+    if (isDate(x)) {
+        x.getDate();
+        x.getHuors();
+          ~~~~~~~~
+!!! error TS2339: Property 'getHuors' does not exist on type 'Date'.
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/narrowFromAnyWithTypePredicate.js b/tests/baselines/reference/narrowFromAnyWithTypePredicate.js
new file mode 100644
index 0000000000000..958a3cfd70daf
--- /dev/null
+++ b/tests/baselines/reference/narrowFromAnyWithTypePredicate.js
@@ -0,0 +1,60 @@
+//// [narrowFromAnyWithTypePredicate.ts]
+declare var x: any;
+declare function isFunction(x): x is Function;
+declare function isObject(x): x is Object;
+declare function isAnything(x): x is {};
+declare function isError(x): x is Error;
+declare function isDate(x): x is Date;
+
+
+if (isFunction(x)) { // 'any' is not narrowed when target type is 'Function'
+    x();
+    x(1, 2, 3);
+    x("hello!");
+    x.prop;
+}
+
+if (isObject(x)) { // 'any' is not narrowed when target type is 'Object'
+    x.method();
+    x();
+}
+
+if (isAnything(x)) { // 'any' is narrowed to types other than 'Function'/'Object' (including {})
+    x.method();
+    x();
+}
+
+if (isError(x)) { 
+    x.message;
+    x.mesage;
+}
+
+if (isDate(x)) {
+    x.getDate();
+    x.getHuors();
+}
+
+
+//// [narrowFromAnyWithTypePredicate.js]
+if (isFunction(x)) {
+    x();
+    x(1, 2, 3);
+    x("hello!");
+    x.prop;
+}
+if (isObject(x)) {
+    x.method();
+    x();
+}
+if (isAnything(x)) {
+    x.method();
+    x();
+}
+if (isError(x)) {
+    x.message;
+    x.mesage;
+}
+if (isDate(x)) {
+    x.getDate();
+    x.getHuors();
+}
diff --git a/tests/baselines/reference/nativeToBoxedTypes.errors.txt b/tests/baselines/reference/nativeToBoxedTypes.errors.txt
new file mode 100644
index 0000000000000..03186a6d7e340
--- /dev/null
+++ b/tests/baselines/reference/nativeToBoxedTypes.errors.txt
@@ -0,0 +1,36 @@
+tests/cases/compiler/nativeToBoxedTypes.ts(3,1): error TS2322: Type 'Number' is not assignable to type 'number'.
+  'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
+tests/cases/compiler/nativeToBoxedTypes.ts(7,1): error TS2322: Type 'String' is not assignable to type 'string'.
+  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
+tests/cases/compiler/nativeToBoxedTypes.ts(11,1): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+  'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
+tests/cases/compiler/nativeToBoxedTypes.ts(14,10): error TS2304: Cannot find name 'Symbol'.
+
+
+==== tests/cases/compiler/nativeToBoxedTypes.ts (4 errors) ====
+    var N = new Number();
+    var n = 100;
+    n = N;
+    ~
+!!! error TS2322: Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:   'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
+    
+    var S = new String();
+    var s = "foge";
+    s = S;
+    ~
+!!! error TS2322: Type 'String' is not assignable to type 'string'.
+!!! error TS2322:   'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
+    
+    var B = new Boolean();
+    var b = true;
+    b = B;
+    ~
+!!! error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+!!! error TS2322:   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
+    
+    var sym: symbol; 
+    var Sym: Symbol;
+             ~~~~~~
+!!! error TS2304: Cannot find name 'Symbol'.
+    sym = Sym;
\ No newline at end of file
diff --git a/tests/baselines/reference/nativeToBoxedTypes.js b/tests/baselines/reference/nativeToBoxedTypes.js
new file mode 100644
index 0000000000000..db47c72fa10f0
--- /dev/null
+++ b/tests/baselines/reference/nativeToBoxedTypes.js
@@ -0,0 +1,30 @@
+//// [nativeToBoxedTypes.ts]
+var N = new Number();
+var n = 100;
+n = N;
+
+var S = new String();
+var s = "foge";
+s = S;
+
+var B = new Boolean();
+var b = true;
+b = B;
+
+var sym: symbol; 
+var Sym: Symbol;
+sym = Sym;
+
+//// [nativeToBoxedTypes.js]
+var N = new Number();
+var n = 100;
+n = N;
+var S = new String();
+var s = "foge";
+s = S;
+var B = new Boolean();
+var b = true;
+b = B;
+var sym;
+var Sym;
+sym = Sym;
diff --git a/tests/baselines/reference/nestedLoopTypeGuards.js b/tests/baselines/reference/nestedLoopTypeGuards.js
new file mode 100644
index 0000000000000..ab1148413ef30
--- /dev/null
+++ b/tests/baselines/reference/nestedLoopTypeGuards.js
@@ -0,0 +1,63 @@
+//// [nestedLoopTypeGuards.ts]
+// Repros from #10378
+
+function f1() {
+    var a: boolean | number | string;
+    if (typeof a !== 'boolean') {
+        // a is narrowed to "number | string"
+        for (var i = 0; i < 1; i++) {
+            for (var j = 0; j < 1; j++) {}
+            if (typeof a === 'string') {
+                // a is narrowed to "string'
+                for (var j = 0; j < 1; j++) {
+                    a.length; // Should not error here
+                }
+            }
+        }
+    }
+}
+
+function f2() {
+    var a: string | number;
+    if (typeof a === 'string') {
+        while (1) {
+            while (1) {}
+            if (typeof a === 'string') {
+                while (1) {
+                    a.length; // Should not error here
+                }
+            }
+        }
+    }
+}
+
+//// [nestedLoopTypeGuards.js]
+// Repros from #10378
+function f1() {
+    var a;
+    if (typeof a !== 'boolean') {
+        // a is narrowed to "number | string"
+        for (var i = 0; i < 1; i++) {
+            for (var j = 0; j < 1; j++) { }
+            if (typeof a === 'string') {
+                // a is narrowed to "string'
+                for (var j = 0; j < 1; j++) {
+                    a.length; // Should not error here
+                }
+            }
+        }
+    }
+}
+function f2() {
+    var a;
+    if (typeof a === 'string') {
+        while (1) {
+            while (1) { }
+            if (typeof a === 'string') {
+                while (1) {
+                    a.length; // Should not error here
+                }
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/nestedLoopTypeGuards.symbols b/tests/baselines/reference/nestedLoopTypeGuards.symbols
new file mode 100644
index 0000000000000..74426576d5a2c
--- /dev/null
+++ b/tests/baselines/reference/nestedLoopTypeGuards.symbols
@@ -0,0 +1,66 @@
+=== tests/cases/compiler/nestedLoopTypeGuards.ts ===
+// Repros from #10378
+
+function f1() {
+>f1 : Symbol(f1, Decl(nestedLoopTypeGuards.ts, 0, 0))
+
+    var a: boolean | number | string;
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 3, 7))
+
+    if (typeof a !== 'boolean') {
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 3, 7))
+
+        // a is narrowed to "number | string"
+        for (var i = 0; i < 1; i++) {
+>i : Symbol(i, Decl(nestedLoopTypeGuards.ts, 6, 16))
+>i : Symbol(i, Decl(nestedLoopTypeGuards.ts, 6, 16))
+>i : Symbol(i, Decl(nestedLoopTypeGuards.ts, 6, 16))
+
+            for (var j = 0; j < 1; j++) {}
+>j : Symbol(j, Decl(nestedLoopTypeGuards.ts, 7, 20), Decl(nestedLoopTypeGuards.ts, 10, 24))
+>j : Symbol(j, Decl(nestedLoopTypeGuards.ts, 7, 20), Decl(nestedLoopTypeGuards.ts, 10, 24))
+>j : Symbol(j, Decl(nestedLoopTypeGuards.ts, 7, 20), Decl(nestedLoopTypeGuards.ts, 10, 24))
+
+            if (typeof a === 'string') {
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 3, 7))
+
+                // a is narrowed to "string'
+                for (var j = 0; j < 1; j++) {
+>j : Symbol(j, Decl(nestedLoopTypeGuards.ts, 7, 20), Decl(nestedLoopTypeGuards.ts, 10, 24))
+>j : Symbol(j, Decl(nestedLoopTypeGuards.ts, 7, 20), Decl(nestedLoopTypeGuards.ts, 10, 24))
+>j : Symbol(j, Decl(nestedLoopTypeGuards.ts, 7, 20), Decl(nestedLoopTypeGuards.ts, 10, 24))
+
+                    a.length; // Should not error here
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 3, 7))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+                }
+            }
+        }
+    }
+}
+
+function f2() {
+>f2 : Symbol(f2, Decl(nestedLoopTypeGuards.ts, 16, 1))
+
+    var a: string | number;
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 19, 7))
+
+    if (typeof a === 'string') {
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 19, 7))
+
+        while (1) {
+            while (1) {}
+            if (typeof a === 'string') {
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 19, 7))
+
+                while (1) {
+                    a.length; // Should not error here
+>a.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>a : Symbol(a, Decl(nestedLoopTypeGuards.ts, 19, 7))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+                }
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/nestedLoopTypeGuards.types b/tests/baselines/reference/nestedLoopTypeGuards.types
new file mode 100644
index 0000000000000..9611fba2fbf30
--- /dev/null
+++ b/tests/baselines/reference/nestedLoopTypeGuards.types
@@ -0,0 +1,96 @@
+=== tests/cases/compiler/nestedLoopTypeGuards.ts ===
+// Repros from #10378
+
+function f1() {
+>f1 : () => void
+
+    var a: boolean | number | string;
+>a : string | number | boolean
+
+    if (typeof a !== 'boolean') {
+>typeof a !== 'boolean' : boolean
+>typeof a : string
+>a : string | number | boolean
+>'boolean' : "boolean"
+
+        // a is narrowed to "number | string"
+        for (var i = 0; i < 1; i++) {
+>i : number
+>0 : number
+>i < 1 : boolean
+>i : number
+>1 : number
+>i++ : number
+>i : number
+
+            for (var j = 0; j < 1; j++) {}
+>j : number
+>0 : number
+>j < 1 : boolean
+>j : number
+>1 : number
+>j++ : number
+>j : number
+
+            if (typeof a === 'string') {
+>typeof a === 'string' : boolean
+>typeof a : string
+>a : string | number
+>'string' : "string"
+
+                // a is narrowed to "string'
+                for (var j = 0; j < 1; j++) {
+>j : number
+>0 : number
+>j < 1 : boolean
+>j : number
+>1 : number
+>j++ : number
+>j : number
+
+                    a.length; // Should not error here
+>a.length : number
+>a : string
+>length : number
+                }
+            }
+        }
+    }
+}
+
+function f2() {
+>f2 : () => void
+
+    var a: string | number;
+>a : string | number
+
+    if (typeof a === 'string') {
+>typeof a === 'string' : boolean
+>typeof a : string
+>a : string | number
+>'string' : "string"
+
+        while (1) {
+>1 : number
+
+            while (1) {}
+>1 : number
+
+            if (typeof a === 'string') {
+>typeof a === 'string' : boolean
+>typeof a : string
+>a : string
+>'string' : "string"
+
+                while (1) {
+>1 : number
+
+                    a.length; // Should not error here
+>a.length : number
+>a : string
+>length : number
+                }
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/noErrorTruncation.errors.txt b/tests/baselines/reference/noErrorTruncation.errors.txt
new file mode 100644
index 0000000000000..d27fad84e5031
--- /dev/null
+++ b/tests/baselines/reference/noErrorTruncation.errors.txt
@@ -0,0 +1,22 @@
+tests/cases/compiler/noErrorTruncation.ts(10,7): error TS2322: Type 'number' is not assignable to type '{ someLongOptionA: string; } | { someLongOptionB: string; } | { someLongOptionC: string; } | { someLongOptionD: string; } | { someLongOptionE: string; } | { someLongOptionF: string; }'.
+
+
+==== tests/cases/compiler/noErrorTruncation.ts (1 errors) ====
+    // @noErrorTruncation
+    
+    type SomeLongOptionA = { someLongOptionA: string }
+    type SomeLongOptionB = { someLongOptionB: string }
+    type SomeLongOptionC = { someLongOptionC: string }
+    type SomeLongOptionD = { someLongOptionD: string }
+    type SomeLongOptionE = { someLongOptionE: string }
+    type SomeLongOptionF = { someLongOptionF: string }
+    
+    const x: SomeLongOptionA
+          ~
+!!! error TS2322: Type 'number' is not assignable to type '{ someLongOptionA: string; } | { someLongOptionB: string; } | { someLongOptionC: string; } | { someLongOptionD: string; } | { someLongOptionE: string; } | { someLongOptionF: string; }'.
+           | SomeLongOptionB
+           | SomeLongOptionC
+           | SomeLongOptionD
+           | SomeLongOptionE
+           | SomeLongOptionF = 42;
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/noErrorTruncation.js b/tests/baselines/reference/noErrorTruncation.js
new file mode 100644
index 0000000000000..70bbc6bd8dc94
--- /dev/null
+++ b/tests/baselines/reference/noErrorTruncation.js
@@ -0,0 +1,21 @@
+//// [noErrorTruncation.ts]
+// @noErrorTruncation
+
+type SomeLongOptionA = { someLongOptionA: string }
+type SomeLongOptionB = { someLongOptionB: string }
+type SomeLongOptionC = { someLongOptionC: string }
+type SomeLongOptionD = { someLongOptionD: string }
+type SomeLongOptionE = { someLongOptionE: string }
+type SomeLongOptionF = { someLongOptionF: string }
+
+const x: SomeLongOptionA
+       | SomeLongOptionB
+       | SomeLongOptionC
+       | SomeLongOptionD
+       | SomeLongOptionE
+       | SomeLongOptionF = 42;
+
+
+//// [noErrorTruncation.js]
+// @noErrorTruncation
+var x = 42;
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.errors.txt b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.errors.txt
index 10d6b05c62203..f7e6475b971ca 100644
--- a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.errors.txt
+++ b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.errors.txt
@@ -15,11 +15,14 @@ tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(5,18): error TS
 tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(7,5): error TS1182: A destructuring declaration must have an initializer.
 tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(7,13): error TS7008: Member 'b3' implicitly has an 'any' type.
 tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(7,25): error TS7008: Member 'b3' implicitly has an 'any' type.
-tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,6): error TS7031: Binding element 'a1' implicitly has an 'any' type.
-tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,26): error TS7031: Binding element 'b1' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,6): error TS7031: Binding element 'a4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,26): error TS7031: Binding element 'b4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,46): error TS7005: Variable 'c4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,62): error TS7005: Variable 'd4' implicitly has an 'any' type.
+tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(11,6): error TS7031: Binding element 'a5' implicitly has an 'any' type.
 
 
-==== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts (19 errors) ====
+==== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts (22 errors) ====
     var [a], {b}, c, d; // error
         ~~~
 !!! error TS1182: A destructuring declaration must have an initializer.
@@ -62,8 +65,16 @@ tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts(9,26): error TS
                             ~~
 !!! error TS7008: Member 'b3' implicitly has an 'any' type.
     
-    var [a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null; // error
+    var [a4] = [undefined], {b4} = { b4: null }, c4 = undefined, d4 = null; // error
          ~~
-!!! error TS7031: Binding element 'a1' implicitly has an 'any' type.
+!!! error TS7031: Binding element 'a4' implicitly has an 'any' type.
                              ~~
-!!! error TS7031: Binding element 'b1' implicitly has an 'any' type.
\ No newline at end of file
+!!! error TS7031: Binding element 'b4' implicitly has an 'any' type.
+                                                 ~~
+!!! error TS7005: Variable 'c4' implicitly has an 'any' type.
+                                                                 ~~
+!!! error TS7005: Variable 'd4' implicitly has an 'any' type.
+    
+    var [a5 = undefined] = []; // error
+         ~~
+!!! error TS7031: Binding element 'a5' implicitly has an 'any' type.
\ No newline at end of file
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.js b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.js
index cbc15c01e9e6d..85358df666ede 100644
--- a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.js
+++ b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration.js
@@ -7,11 +7,14 @@ var [a2]: [any], {b2}: { b2: any }, c2: any, d2: any;
 
 var {b3}: { b3 }, c3: { b3 }; // error in type instead
 
-var [a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null; // error
+var [a4] = [undefined], {b4} = { b4: null }, c4 = undefined, d4 = null; // error
+
+var [a5 = undefined] = []; // error
 
 //// [noImplicitAnyDestructuringVarDeclaration.js]
 var a = (void 0)[0], b = (void 0).b, c, d; // error
 var _a = (void 0)[0], a1 = _a === void 0 ? undefined : _a, _b = (void 0).b1, b1 = _b === void 0 ? null : _b, c1 = undefined, d1 = null; // error
 var a2 = (void 0)[0], b2 = (void 0).b2, c2, d2;
 var b3 = (void 0).b3, c3; // error in type instead
-var a1 = [undefined][0], b1 = { b1: null }.b1, c1 = undefined, d1 = null; // error
+var a4 = [undefined][0], b4 = { b4: null }.b4, c4 = undefined, d4 = null; // error
+var _c = [][0], a5 = _c === void 0 ? undefined : _c; // error
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.js b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.js
new file mode 100644
index 0000000000000..79ee0b8830ffc
--- /dev/null
+++ b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.js
@@ -0,0 +1,25 @@
+//// [noImplicitAnyDestructuringVarDeclaration2.ts]
+let [a, b, c] = [1, 2, 3]; // no error
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
+
+
+//// [noImplicitAnyDestructuringVarDeclaration2.js]
+var _a = [1, 2, 3], a = _a[0], b = _a[1], c = _a[2]; // no error
+var _b = [1, 2, 3], _c = _b[0], a1 = _c === void 0 ? 10 : _c, _d = _b[1], b1 = _d === void 0 ? 10 : _d, _e = _b[2], c1 = _e === void 0 ? 10 : _e; // no error
+var _f = [1, 2, 3], _g = _f[0], a2 = _g === void 0 ? undefined : _g, _h = _f[1], b2 = _h === void 0 ? undefined : _h, _j = _f[2], c2 = _j === void 0 ? undefined : _j; // no error
+var _k = [1, 2, 3], _l = _k[0], a3 = _l === void 0 ? undefined : _l, _m = _k[1], b3 = _m === void 0 ? null : _m, _o = _k[2], c3 = _o === void 0 ? undefined : _o; // no error
+var a4 = [undefined][0], b4 = [null][0], c4 = undefined, d4 = null; // no error
+var _p = { x: 1, y: 2, z: 3 }, x = _p.x, y = _p.y, z = _p.z; // no error
+var _q = { x1: 1, y1: 2, z1: 3 }, _r = _q.x1, x1 = _r === void 0 ? 10 : _r, _s = _q.y1, y1 = _s === void 0 ? 10 : _s, _t = _q.z1, z1 = _t === void 0 ? 10 : _t; // no error
+var _u = { x2: 1, y2: 2, z2: 3 }, _v = _u.x2, x2 = _v === void 0 ? undefined : _v, _w = _u.y2, y2 = _w === void 0 ? undefined : _w, _x = _u.z2, z2 = _x === void 0 ? undefined : _x; // no error
+var _y = { x3: 1, y3: 2, z3: 3 }, _z = _y.x3, x3 = _z === void 0 ? undefined : _z, _0 = _y.y3, y3 = _0 === void 0 ? null : _0, _1 = _y.z3, z3 = _1 === void 0 ? undefined : _1; // no error
+var x4 = { x4: undefined }.x4, y4 = { y4: null }.y4; // no error
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.symbols b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.symbols
new file mode 100644
index 0000000000000..ee7fe9f7edd9f
--- /dev/null
+++ b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.symbols
@@ -0,0 +1,78 @@
+=== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts ===
+let [a, b, c] = [1, 2, 3]; // no error
+>a : Symbol(a, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 0, 5))
+>b : Symbol(b, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 0, 7))
+>c : Symbol(c, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 0, 10))
+
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+>a1 : Symbol(a1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 1, 5))
+>b1 : Symbol(b1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 1, 13))
+>c1 : Symbol(c1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 1, 22))
+
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+>a2 : Symbol(a2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 2, 5))
+>undefined : Symbol(undefined)
+>b2 : Symbol(b2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 2, 20))
+>undefined : Symbol(undefined)
+>c2 : Symbol(c2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 2, 36))
+>undefined : Symbol(undefined)
+
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+>a3 : Symbol(a3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 3, 5))
+>undefined : Symbol(undefined)
+>b3 : Symbol(b3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 3, 25))
+>c3 : Symbol(c3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 3, 41))
+>undefined : Symbol(undefined)
+
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+>a4 : Symbol(a4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 5))
+>undefined : Symbol(undefined)
+>b4 : Symbol(b4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 30))
+>c4 : Symbol(c4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 48))
+>undefined : Symbol(undefined)
+>d4 : Symbol(d4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 4, 69))
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+>x : Symbol(x, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 5))
+>y : Symbol(y, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 7))
+>z : Symbol(z, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 10))
+>x : Symbol(x, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 17))
+>y : Symbol(y, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 23))
+>z : Symbol(z, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 6, 29))
+
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+>x1 : Symbol(x1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 5))
+>y1 : Symbol(y1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 13))
+>z1 : Symbol(z1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 22))
+>x1 : Symbol(x1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 35))
+>y1 : Symbol(y1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 42))
+>z1 : Symbol(z1, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 7, 49))
+
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+>x2 : Symbol(x2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 5))
+>undefined : Symbol(undefined)
+>y2 : Symbol(y2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 20))
+>undefined : Symbol(undefined)
+>z2 : Symbol(z2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 36))
+>undefined : Symbol(undefined)
+>x2 : Symbol(x2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 56))
+>y2 : Symbol(y2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 63))
+>z2 : Symbol(z2, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 8, 70))
+
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+>x3 : Symbol(x3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 5))
+>undefined : Symbol(undefined)
+>y3 : Symbol(y3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 25))
+>z3 : Symbol(z3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 41))
+>undefined : Symbol(undefined)
+>x3 : Symbol(x3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 66))
+>y3 : Symbol(y3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 73))
+>z3 : Symbol(z3, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 9, 80))
+
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
+>x4 : Symbol(x4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 5))
+>x4 : Symbol(x4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 12))
+>undefined : Symbol(undefined)
+>y4 : Symbol(y4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 36))
+>y4 : Symbol(y4, Decl(noImplicitAnyDestructuringVarDeclaration2.ts, 10, 43))
+
diff --git a/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.types b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.types
new file mode 100644
index 0000000000000..ef0a3f2c25b63
--- /dev/null
+++ b/tests/baselines/reference/noImplicitAnyDestructuringVarDeclaration2.types
@@ -0,0 +1,137 @@
+=== tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts ===
+let [a, b, c] = [1, 2, 3]; // no error
+>a : number
+>b : number
+>c : number
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+>a1 : number
+>10 : number
+>b1 : number
+>10 : number
+>c1 : number
+>10 : number
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+>a2 : number
+>undefined : undefined
+>b2 : number
+>undefined : undefined
+>c2 : number
+>undefined : undefined
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+>a3 : number
+><any>undefined : any
+>undefined : undefined
+>b3 : number
+><any>null : any
+>null : null
+>c3 : number
+><any>undefined : any
+>undefined : undefined
+>[1, 2, 3] : [number, number, number]
+>1 : number
+>2 : number
+>3 : number
+
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+>a4 : any
+>[<any>undefined] : [any]
+><any>undefined : any
+>undefined : undefined
+>b4 : any
+>[<any>null] : [any]
+><any>null : any
+>null : null
+>c4 : any
+><any>undefined : any
+>undefined : undefined
+>d4 : any
+><any>null : any
+>null : null
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+>x : number
+>y : number
+>z : number
+>{ x: 1, y: 2, z: 3 } : { x: number; y: number; z: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+>z : number
+>3 : number
+
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+>x1 : number
+>10 : number
+>y1 : number
+>10 : number
+>z1 : number
+>10 : number
+>{ x1: 1, y1: 2, z1: 3 } : { x1?: number; y1?: number; z1?: number; }
+>x1 : number
+>1 : number
+>y1 : number
+>2 : number
+>z1 : number
+>3 : number
+
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+>x2 : number
+>undefined : undefined
+>y2 : number
+>undefined : undefined
+>z2 : number
+>undefined : undefined
+>{ x2: 1, y2: 2, z2: 3 } : { x2?: number; y2?: number; z2?: number; }
+>x2 : number
+>1 : number
+>y2 : number
+>2 : number
+>z2 : number
+>3 : number
+
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+>x3 : number
+><any>undefined : any
+>undefined : undefined
+>y3 : number
+><any>null : any
+>null : null
+>z3 : number
+><any>undefined : any
+>undefined : undefined
+>{ x3: 1, y3: 2, z3: 3 } : { x3?: number; y3?: number; z3?: number; }
+>x3 : number
+>1 : number
+>y3 : number
+>2 : number
+>z3 : number
+>3 : number
+
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
+>x4 : any
+>{ x4: <any>undefined } : { x4: any; }
+>x4 : any
+><any>undefined : any
+>undefined : undefined
+>y4 : any
+>{ y4: <any>null } : { y4: any; }
+>y4 : any
+><any>null : any
+>null : null
+
diff --git a/tests/baselines/reference/optionalBindingParameters1.errors.txt b/tests/baselines/reference/optionalBindingParameters1.errors.txt
index 78fc1cbddf1f7..0780c626baf8b 100644
--- a/tests/baselines/reference/optionalBindingParameters1.errors.txt
+++ b/tests/baselines/reference/optionalBindingParameters1.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
 tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-  Types of property '0' are incompatible.
-    Type 'boolean' is not assignable to type 'string'.
+  Type 'boolean' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts (2 errors) ====
@@ -17,5 +16,4 @@ tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): er
     foo([false, 0, ""]);
         ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-!!! error TS2345:   Types of property '0' are incompatible.
-!!! error TS2345:     Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
+!!! error TS2345:   Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt
index 312603d2c2e62..30ec4037c88b6 100644
--- a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt
+++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt
@@ -1,6 +1,5 @@
 tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(9,5): error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-  Types of property '0' are incompatible.
-    Type 'boolean' is not assignable to type 'string'.
+  Type 'boolean' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts (1 errors) ====
@@ -15,5 +14,4 @@ tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.
     foo([false, 0, ""]);
         ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-!!! error TS2345:   Types of property '0' are incompatible.
-!!! error TS2345:     Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
+!!! error TS2345:   Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/primitiveMembers.errors.txt b/tests/baselines/reference/primitiveMembers.errors.txt
index da8b75f9bc577..49ef8c4e3cf0e 100644
--- a/tests/baselines/reference/primitiveMembers.errors.txt
+++ b/tests/baselines/reference/primitiveMembers.errors.txt
@@ -1,5 +1,6 @@
 tests/cases/compiler/primitiveMembers.ts(5,3): error TS2339: Property 'toBAZ' does not exist on type 'number'.
 tests/cases/compiler/primitiveMembers.ts(11,1): error TS2322: Type 'Number' is not assignable to type 'number'.
+  'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 
 
 ==== tests/cases/compiler/primitiveMembers.ts (2 errors) ====
@@ -18,6 +19,7 @@ tests/cases/compiler/primitiveMembers.ts(11,1): error TS2322: Type 'Number' is n
     n = N;  // should not work, as 'number' has a different brand
     ~
 !!! error TS2322: Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:   'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     N = n; // should work
     
     var o: Object = {}
diff --git a/tests/baselines/reference/staticInstanceResolution5.errors.txt b/tests/baselines/reference/staticInstanceResolution5.errors.txt
index da6f0fde1433a..f36851b2b97e8 100644
--- a/tests/baselines/reference/staticInstanceResolution5.errors.txt
+++ b/tests/baselines/reference/staticInstanceResolution5.errors.txt
@@ -4,7 +4,7 @@ tests/cases/compiler/staticInstanceResolution5_1.ts(6,16): error TS2304: Cannot
 
 
 ==== tests/cases/compiler/staticInstanceResolution5_1.ts (3 errors) ====
-    import WinJS = require('staticInstanceResolution5_0.ts');
+    import WinJS = require('staticInstanceResolution5_0');
     
     // these 3 should be errors
     var x = (w1: WinJS) => { };
diff --git a/tests/baselines/reference/staticInstanceResolution5.js b/tests/baselines/reference/staticInstanceResolution5.js
index 0809d1af5f059..b3514e00aad87 100644
--- a/tests/baselines/reference/staticInstanceResolution5.js
+++ b/tests/baselines/reference/staticInstanceResolution5.js
@@ -8,7 +8,7 @@ export class Promise {
 }
 
 //// [staticInstanceResolution5_1.ts]
-import WinJS = require('staticInstanceResolution5_0.ts');
+import WinJS = require('staticInstanceResolution5_0');
 
 // these 3 should be errors
 var x = (w1: WinJS) => { };
diff --git a/tests/baselines/reference/stringLiteralTypesAsTags01.types b/tests/baselines/reference/stringLiteralTypesAsTags01.types
index e00fd18163dd6..e95a7364f9340 100644
--- a/tests/baselines/reference/stringLiteralTypesAsTags01.types
+++ b/tests/baselines/reference/stringLiteralTypesAsTags01.types
@@ -99,8 +99,8 @@ if (hasKind(x, "A")) {
 }
 else {
     let b = x;
->b : A
->x : A
+>b : never
+>x : never
 }
 
 if (!hasKind(x, "B")) {
diff --git a/tests/baselines/reference/stringLiteralTypesAsTags02.types b/tests/baselines/reference/stringLiteralTypesAsTags02.types
index fb1632559ea90..c984b8a78f9ba 100644
--- a/tests/baselines/reference/stringLiteralTypesAsTags02.types
+++ b/tests/baselines/reference/stringLiteralTypesAsTags02.types
@@ -93,8 +93,8 @@ if (hasKind(x, "A")) {
 }
 else {
     let b = x;
->b : A
->x : A
+>b : never
+>x : never
 }
 
 if (!hasKind(x, "B")) {
diff --git a/tests/baselines/reference/stringLiteralTypesAsTags03.types b/tests/baselines/reference/stringLiteralTypesAsTags03.types
index 05be633813b49..fbe71ff07c188 100644
--- a/tests/baselines/reference/stringLiteralTypesAsTags03.types
+++ b/tests/baselines/reference/stringLiteralTypesAsTags03.types
@@ -96,8 +96,8 @@ if (hasKind(x, "A")) {
 }
 else {
     let b = x;
->b : A
->x : A
+>b : never
+>x : never
 }
 
 if (!hasKind(x, "B")) {
diff --git a/tests/baselines/reference/symbolType15.errors.txt b/tests/baselines/reference/symbolType15.errors.txt
index eb63e5798d5e2..205a2a999d0d4 100644
--- a/tests/baselines/reference/symbolType15.errors.txt
+++ b/tests/baselines/reference/symbolType15.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/conformance/es6/Symbols/symbolType15.ts(5,1): error TS2322: Type 'Symbol' is not assignable to type 'symbol'.
+  'symbol' is a primitive, but 'Symbol' is a wrapper object. Prefer using 'symbol' when possible.
 
 
 ==== tests/cases/conformance/es6/Symbols/symbolType15.ts (1 errors) ====
@@ -8,4 +9,5 @@ tests/cases/conformance/es6/Symbols/symbolType15.ts(5,1): error TS2322: Type 'Sy
     symObj = sym;
     sym = symObj;
     ~~~
-!!! error TS2322: Type 'Symbol' is not assignable to type 'symbol'.
\ No newline at end of file
+!!! error TS2322: Type 'Symbol' is not assignable to type 'symbol'.
+!!! error TS2322:   'symbol' is a primitive, but 'Symbol' is a wrapper object. Prefer using 'symbol' when possible.
\ No newline at end of file
diff --git a/tests/baselines/reference/thisInTupleTypeParameterConstraints.js b/tests/baselines/reference/thisInTupleTypeParameterConstraints.js
new file mode 100644
index 0000000000000..c63fbf6199124
--- /dev/null
+++ b/tests/baselines/reference/thisInTupleTypeParameterConstraints.js
@@ -0,0 +1,29 @@
+//// [thisInTupleTypeParameterConstraints.ts]
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+interface IArguments {}
+interface Function {}
+interface Number {}
+interface RegExp {}
+interface Object {}
+interface String {}
+
+interface Array<T> {
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+    reduceRight<U>(arg: this): void;
+    reduce<U>(arg: this): void;
+    reduce2<U>(arg: this): void;
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+let x: [(x: number) => number];
+f(x);
+
+
+//// [thisInTupleTypeParameterConstraints.js]
+/// <reference no-default-lib="true"/>
+var x;
+f(x);
diff --git a/tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols b/tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols
new file mode 100644
index 0000000000000..4d2bef22c55fe
--- /dev/null
+++ b/tests/baselines/reference/thisInTupleTypeParameterConstraints.symbols
@@ -0,0 +1,66 @@
+=== tests/cases/compiler/thisInTupleTypeParameterConstraints.ts ===
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+>Boolean : Symbol(Boolean, Decl(thisInTupleTypeParameterConstraints.ts, 0, 0))
+
+interface IArguments {}
+>IArguments : Symbol(IArguments, Decl(thisInTupleTypeParameterConstraints.ts, 2, 20))
+
+interface Function {}
+>Function : Symbol(Function, Decl(thisInTupleTypeParameterConstraints.ts, 3, 23))
+
+interface Number {}
+>Number : Symbol(Number, Decl(thisInTupleTypeParameterConstraints.ts, 4, 21))
+
+interface RegExp {}
+>RegExp : Symbol(RegExp, Decl(thisInTupleTypeParameterConstraints.ts, 5, 19))
+
+interface Object {}
+>Object : Symbol(Object, Decl(thisInTupleTypeParameterConstraints.ts, 6, 19))
+
+interface String {}
+>String : Symbol(String, Decl(thisInTupleTypeParameterConstraints.ts, 7, 19))
+
+interface Array<T> {
+>Array : Symbol(Array, Decl(thisInTupleTypeParameterConstraints.ts, 8, 19))
+>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 10, 16))
+
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+>map : Symbol(Array.map, Decl(thisInTupleTypeParameterConstraints.ts, 10, 20))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 13, 8))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 13, 11))
+
+    reduceRight<U>(arg: this): void;
+>reduceRight : Symbol(Array.reduceRight, Decl(thisInTupleTypeParameterConstraints.ts, 13, 28))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 14, 16))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 14, 19))
+
+    reduce<U>(arg: this): void;
+>reduce : Symbol(Array.reduce, Decl(thisInTupleTypeParameterConstraints.ts, 14, 36))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 15, 11))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 15, 14))
+
+    reduce2<U>(arg: this): void;
+>reduce2 : Symbol(Array.reduce2, Decl(thisInTupleTypeParameterConstraints.ts, 15, 31))
+>U : Symbol(U, Decl(thisInTupleTypeParameterConstraints.ts, 16, 12))
+>arg : Symbol(arg, Decl(thisInTupleTypeParameterConstraints.ts, 16, 15))
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+>f : Symbol(f, Decl(thisInTupleTypeParameterConstraints.ts, 17, 1))
+>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 19, 19))
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 19, 31))
+>a : Symbol(a, Decl(thisInTupleTypeParameterConstraints.ts, 19, 54))
+>T : Symbol(T, Decl(thisInTupleTypeParameterConstraints.ts, 19, 19))
+
+let x: [(x: number) => number];
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 3))
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 9))
+
+f(x);
+>f : Symbol(f, Decl(thisInTupleTypeParameterConstraints.ts, 17, 1))
+>x : Symbol(x, Decl(thisInTupleTypeParameterConstraints.ts, 20, 3))
+
diff --git a/tests/baselines/reference/thisInTupleTypeParameterConstraints.types b/tests/baselines/reference/thisInTupleTypeParameterConstraints.types
new file mode 100644
index 0000000000000..7daafe02bfc7e
--- /dev/null
+++ b/tests/baselines/reference/thisInTupleTypeParameterConstraints.types
@@ -0,0 +1,67 @@
+=== tests/cases/compiler/thisInTupleTypeParameterConstraints.ts ===
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+>Boolean : Boolean
+
+interface IArguments {}
+>IArguments : IArguments
+
+interface Function {}
+>Function : Function
+
+interface Number {}
+>Number : Number
+
+interface RegExp {}
+>RegExp : RegExp
+
+interface Object {}
+>Object : Object
+
+interface String {}
+>String : String
+
+interface Array<T> {
+>Array : T[]
+>T : T
+
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+>map : <U>(arg: this) => void
+>U : U
+>arg : this
+
+    reduceRight<U>(arg: this): void;
+>reduceRight : <U>(arg: this) => void
+>U : U
+>arg : this
+
+    reduce<U>(arg: this): void;
+>reduce : <U>(arg: this) => void
+>U : U
+>arg : this
+
+    reduce2<U>(arg: this): void;
+>reduce2 : <U>(arg: this) => void
+>U : U
+>arg : this
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+>f : <T extends [(x: number) => number]>(a: T) => void
+>T : T
+>x : number
+>a : T
+>T : T
+
+let x: [(x: number) => number];
+>x : [(x: number) => number]
+>x : number
+
+f(x);
+>f(x) : void
+>f : <T extends [(x: number) => number]>(a: T) => void
+>x : [(x: number) => number]
+
diff --git a/tests/baselines/reference/thisTypeInFunctions.symbols b/tests/baselines/reference/thisTypeInFunctions.symbols
index 8a0be7427ed4c..ad16785f28830 100644
--- a/tests/baselines/reference/thisTypeInFunctions.symbols
+++ b/tests/baselines/reference/thisTypeInFunctions.symbols
@@ -135,7 +135,7 @@ let impl: I = {
 
         return this.a;
 >this.a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
->this : Symbol(, Decl(thisTypeInFunctions.ts, 24, 28))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 24, 23))
 >a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
 
     },
@@ -144,7 +144,7 @@ let impl: I = {
 
         return this.a;
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 25, 22))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
     },
@@ -153,7 +153,7 @@ let impl: I = {
 
         return this.a;
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 26, 17))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
     },
@@ -173,7 +173,7 @@ impl.explicitStructural = function() { return this.a; };
 >impl : Symbol(impl, Decl(thisTypeInFunctions.ts, 37, 3))
 >explicitStructural : Symbol(I.explicitStructural, Decl(thisTypeInFunctions.ts, 23, 38))
 >this.a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
->this : Symbol(, Decl(thisTypeInFunctions.ts, 24, 28))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 24, 23))
 >a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
 
 impl.explicitInterface = function() { return this.a; };
@@ -181,7 +181,7 @@ impl.explicitInterface = function() { return this.a; };
 >impl : Symbol(impl, Decl(thisTypeInFunctions.ts, 37, 3))
 >explicitInterface : Symbol(I.explicitInterface, Decl(thisTypeInFunctions.ts, 24, 50))
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 25, 22))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
 impl.explicitStructural = () => 12;
@@ -199,7 +199,7 @@ impl.explicitThis = function () { return this.a; };
 >impl : Symbol(impl, Decl(thisTypeInFunctions.ts, 37, 3))
 >explicitThis : Symbol(I.explicitThis, Decl(thisTypeInFunctions.ts, 25, 39))
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 26, 17))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
 // parameter checking
@@ -536,7 +536,7 @@ c.explicitC = function(m) { return this.n + m };
 >explicitC : Symbol(C.explicitC, Decl(thisTypeInFunctions.ts, 8, 5))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 126, 23))
 >this.n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
->this : Symbol(C, Decl(thisTypeInFunctions.ts, 3, 1))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 9, 14))
 >n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 126, 23))
 
@@ -546,7 +546,7 @@ c.explicitProperty = function(m) { return this.n + m };
 >explicitProperty : Symbol(C.explicitProperty, Decl(thisTypeInFunctions.ts, 11, 5))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 127, 30))
 >this.n : Symbol(n, Decl(thisTypeInFunctions.ts, 12, 28))
->this : Symbol(, Decl(thisTypeInFunctions.ts, 12, 26))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 12, 21))
 >n : Symbol(n, Decl(thisTypeInFunctions.ts, 12, 28))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 127, 30))
 
@@ -556,7 +556,7 @@ c.explicitThis = function(m) { return this.n + m };
 >explicitThis : Symbol(C.explicitThis, Decl(thisTypeInFunctions.ts, 5, 14))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 128, 26))
 >this.n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
->this : Symbol(C, Decl(thisTypeInFunctions.ts, 3, 1))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 6, 17))
 >n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 128, 26))
 
diff --git a/tests/baselines/reference/thisTypeInFunctions.types b/tests/baselines/reference/thisTypeInFunctions.types
index 24c4fb87bafb1..863ecbce628b7 100644
--- a/tests/baselines/reference/thisTypeInFunctions.types
+++ b/tests/baselines/reference/thisTypeInFunctions.types
@@ -132,7 +132,7 @@ function implicitThis(n: number): number {
 let impl: I = {
 >impl : I
 >I : I
->{    a: 12,    explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?)    explicitVoid1() { return 12; },    explicitStructural() {        return this.a;    },    explicitInterface() {        return this.a;    },    explicitThis() {        return this.a;    },} : { a: number; explicitVoid2: () => any; explicitVoid1(): number; explicitStructural(): number; explicitInterface(): number; explicitThis(): number; }
+>{    a: 12,    explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?)    explicitVoid1() { return 12; },    explicitStructural() {        return this.a;    },    explicitInterface() {        return this.a;    },    explicitThis() {        return this.a;    },} : { a: number; explicitVoid2: () => any; explicitVoid1(this: void): number; explicitStructural(this: { a: number; }): number; explicitInterface(this: I): number; explicitThis(this: I): number; }
 
     a: 12,
 >a : number
@@ -146,11 +146,11 @@ let impl: I = {
 >a : any
 
     explicitVoid1() { return 12; },
->explicitVoid1 : () => number
+>explicitVoid1 : (this: void) => number
 >12 : number
 
     explicitStructural() {
->explicitStructural : () => number
+>explicitStructural : (this: { a: number; }) => number
 
         return this.a;
 >this.a : number
@@ -159,7 +159,7 @@ let impl: I = {
 
     },
     explicitInterface() {
->explicitInterface : () => number
+>explicitInterface : (this: I) => number
 
         return this.a;
 >this.a : number
@@ -168,7 +168,7 @@ let impl: I = {
 
     },
     explicitThis() {
->explicitThis : () => number
+>explicitThis : (this: I) => number
 
         return this.a;
 >this.a : number
@@ -178,11 +178,11 @@ let impl: I = {
     },
 }
 impl.explicitVoid1 = function () { return 12; };
->impl.explicitVoid1 = function () { return 12; } : () => number
+>impl.explicitVoid1 = function () { return 12; } : (this: void) => number
 >impl.explicitVoid1 : (this: void) => number
 >impl : I
 >explicitVoid1 : (this: void) => number
->function () { return 12; } : () => number
+>function () { return 12; } : (this: void) => number
 >12 : number
 
 impl.explicitVoid2 = () => 12;
@@ -194,21 +194,21 @@ impl.explicitVoid2 = () => 12;
 >12 : number
 
 impl.explicitStructural = function() { return this.a; };
->impl.explicitStructural = function() { return this.a; } : () => number
+>impl.explicitStructural = function() { return this.a; } : (this: { a: number; }) => number
 >impl.explicitStructural : (this: { a: number; }) => number
 >impl : I
 >explicitStructural : (this: { a: number; }) => number
->function() { return this.a; } : () => number
+>function() { return this.a; } : (this: { a: number; }) => number
 >this.a : number
 >this : { a: number; }
 >a : number
 
 impl.explicitInterface = function() { return this.a; };
->impl.explicitInterface = function() { return this.a; } : () => number
+>impl.explicitInterface = function() { return this.a; } : (this: I) => number
 >impl.explicitInterface : (this: I) => number
 >impl : I
 >explicitInterface : (this: I) => number
->function() { return this.a; } : () => number
+>function() { return this.a; } : (this: I) => number
 >this.a : number
 >this : I
 >a : number
@@ -230,11 +230,11 @@ impl.explicitInterface = () => 12;
 >12 : number
 
 impl.explicitThis = function () { return this.a; };
->impl.explicitThis = function () { return this.a; } : () => number
+>impl.explicitThis = function () { return this.a; } : (this: I) => number
 >impl.explicitThis : (this: I) => number
 >impl : I
 >explicitThis : (this: I) => number
->function () { return this.a; } : () => number
+>function () { return this.a; } : (this: I) => number
 >this.a : number
 >this : I
 >a : number
@@ -433,7 +433,7 @@ let unboundToSpecified: (this: { y: number }, x: number) => number = x => x + th
 >this : { y: number; }
 >y : number
 >x : number
->x => x + this.y : (x: number) => any
+>x => x + this.y : (this: { y: number; }, x: number) => any
 >x : number
 >x + this.y : any
 >x : number
@@ -472,7 +472,7 @@ let specifiedLambda: (this: void, x: number) => number = x => x + 12;
 >specifiedLambda : (this: void, x: number) => number
 >this : void
 >x : number
->x => x + 12 : (x: number) => number
+>x => x + 12 : (this: void, x: number) => number
 >x : number
 >x + 12 : number
 >x : number
@@ -560,40 +560,40 @@ c.explicitProperty = reconstructed.explicitProperty;
 
 // lambdas are assignable to anything
 c.explicitC = m => m;
->c.explicitC = m => m : (m: number) => number
+>c.explicitC = m => m : (this: C, m: number) => number
 >c.explicitC : (this: C, m: number) => number
 >c : C
 >explicitC : (this: C, m: number) => number
->m => m : (m: number) => number
+>m => m : (this: C, m: number) => number
 >m : number
 >m : number
 
 c.explicitThis = m => m;
->c.explicitThis = m => m : (m: number) => number
+>c.explicitThis = m => m : (this: C, m: number) => number
 >c.explicitThis : (this: C, m: number) => number
 >c : C
 >explicitThis : (this: C, m: number) => number
->m => m : (m: number) => number
+>m => m : (this: C, m: number) => number
 >m : number
 >m : number
 
 c.explicitProperty = m => m;
->c.explicitProperty = m => m : (m: number) => number
+>c.explicitProperty = m => m : (this: { n: number; }, m: number) => number
 >c.explicitProperty : (this: { n: number; }, m: number) => number
 >c : C
 >explicitProperty : (this: { n: number; }, m: number) => number
->m => m : (m: number) => number
+>m => m : (this: { n: number; }, m: number) => number
 >m : number
 >m : number
 
 // this inside lambdas refer to outer scope
 // the outer-scoped lambda at top-level is still just `any`
 c.explicitC = m => m + this.n;
->c.explicitC = m => m + this.n : (m: number) => any
+>c.explicitC = m => m + this.n : (this: C, m: number) => any
 >c.explicitC : (this: C, m: number) => number
 >c : C
 >explicitC : (this: C, m: number) => number
->m => m + this.n : (m: number) => any
+>m => m + this.n : (this: C, m: number) => any
 >m : number
 >m + this.n : any
 >m : number
@@ -602,11 +602,11 @@ c.explicitC = m => m + this.n;
 >n : any
 
 c.explicitThis = m => m + this.n;
->c.explicitThis = m => m + this.n : (m: number) => any
+>c.explicitThis = m => m + this.n : (this: C, m: number) => any
 >c.explicitThis : (this: C, m: number) => number
 >c : C
 >explicitThis : (this: C, m: number) => number
->m => m + this.n : (m: number) => any
+>m => m + this.n : (this: C, m: number) => any
 >m : number
 >m + this.n : any
 >m : number
@@ -615,11 +615,11 @@ c.explicitThis = m => m + this.n;
 >n : any
 
 c.explicitProperty = m => m + this.n;
->c.explicitProperty = m => m + this.n : (m: number) => any
+>c.explicitProperty = m => m + this.n : (this: { n: number; }, m: number) => any
 >c.explicitProperty : (this: { n: number; }, m: number) => number
 >c : C
 >explicitProperty : (this: { n: number; }, m: number) => number
->m => m + this.n : (m: number) => any
+>m => m + this.n : (this: { n: number; }, m: number) => any
 >m : number
 >m + this.n : any
 >m : number
@@ -652,11 +652,11 @@ c.explicitThis = function(this: C, m: number) { return this.n + m };
 
 // this:any compatibility
 c.explicitC = function(m) { return this.n + m };
->c.explicitC = function(m) { return this.n + m } : (m: number) => number
+>c.explicitC = function(m) { return this.n + m } : (this: C, m: number) => number
 >c.explicitC : (this: C, m: number) => number
 >c : C
 >explicitC : (this: C, m: number) => number
->function(m) { return this.n + m } : (m: number) => number
+>function(m) { return this.n + m } : (this: C, m: number) => number
 >m : number
 >this.n + m : number
 >this.n : number
@@ -665,11 +665,11 @@ c.explicitC = function(m) { return this.n + m };
 >m : number
 
 c.explicitProperty = function(m) { return this.n + m };
->c.explicitProperty = function(m) { return this.n + m } : (m: number) => number
+>c.explicitProperty = function(m) { return this.n + m } : (this: { n: number; }, m: number) => number
 >c.explicitProperty : (this: { n: number; }, m: number) => number
 >c : C
 >explicitProperty : (this: { n: number; }, m: number) => number
->function(m) { return this.n + m } : (m: number) => number
+>function(m) { return this.n + m } : (this: { n: number; }, m: number) => number
 >m : number
 >this.n + m : number
 >this.n : number
@@ -678,11 +678,11 @@ c.explicitProperty = function(m) { return this.n + m };
 >m : number
 
 c.explicitThis = function(m) { return this.n + m };
->c.explicitThis = function(m) { return this.n + m } : (m: number) => number
+>c.explicitThis = function(m) { return this.n + m } : (this: C, m: number) => number
 >c.explicitThis : (this: C, m: number) => number
 >c : C
 >explicitThis : (this: C, m: number) => number
->function(m) { return this.n + m } : (m: number) => number
+>function(m) { return this.n + m } : (this: C, m: number) => number
 >m : number
 >this.n + m : number
 >this.n : number
@@ -723,11 +723,11 @@ c.explicitC = function(this: B, m: number) { return this.n + m };
 
 // this:void compatibility
 c.explicitVoid = n => n;
->c.explicitVoid = n => n : (n: number) => number
+>c.explicitVoid = n => n : (this: void, n: number) => number
 >c.explicitVoid : (this: void, m: number) => number
 >c : C
 >explicitVoid : (this: void, m: number) => number
->n => n : (n: number) => number
+>n => n : (this: void, n: number) => number
 >n : number
 >n : number
 
diff --git a/tests/baselines/reference/thisTypeInFunctions2.symbols b/tests/baselines/reference/thisTypeInFunctions2.symbols
index cdc7fb321d46f..5cc26e3ad43a3 100644
--- a/tests/baselines/reference/thisTypeInFunctions2.symbols
+++ b/tests/baselines/reference/thisTypeInFunctions2.symbols
@@ -61,12 +61,12 @@ extend1({
 >init : Symbol(init, Decl(thisTypeInFunctions2.ts, 20, 9))
 
         this // this: IndexedWithThis because of contextual typing.
->this : Symbol(IndexedWithThis, Decl(thisTypeInFunctions2.ts, 0, 0))
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 2, 12))
 
         // this.mine
         this.willDestroy
 >this.willDestroy : Symbol(IndexedWithThis.willDestroy, Decl(thisTypeInFunctions2.ts, 2, 32))
->this : Symbol(IndexedWithThis, Decl(thisTypeInFunctions2.ts, 0, 0))
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 2, 12))
 >willDestroy : Symbol(IndexedWithThis.willDestroy, Decl(thisTypeInFunctions2.ts, 2, 32))
 
     },
@@ -77,7 +77,10 @@ extend1({
 >foo : Symbol(foo, Decl(thisTypeInFunctions2.ts, 26, 13))
 
         this.url; // this: any because 'foo' matches the string indexer
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 4, 87))
+
         this.willDestroy;
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 4, 87))
     }
 });
 extend2({
diff --git a/tests/baselines/reference/thisTypeInFunctions2.types b/tests/baselines/reference/thisTypeInFunctions2.types
index 371b5f5cafc17..25fb2f28a6063 100644
--- a/tests/baselines/reference/thisTypeInFunctions2.types
+++ b/tests/baselines/reference/thisTypeInFunctions2.types
@@ -58,10 +58,10 @@ declare function simple(arg: SimpleInterface): void;
 extend1({
 >extend1({    init() {        this // this: IndexedWithThis because of contextual typing.        // this.mine        this.willDestroy    },    mine: 12,    foo() {        this.url; // this: any because 'foo' matches the string indexer        this.willDestroy;    }}) : void
 >extend1 : (args: IndexedWithThis) => void
->{    init() {        this // this: IndexedWithThis because of contextual typing.        // this.mine        this.willDestroy    },    mine: 12,    foo() {        this.url; // this: any because 'foo' matches the string indexer        this.willDestroy;    }} : { init(): void; mine: number; foo(): void; }
+>{    init() {        this // this: IndexedWithThis because of contextual typing.        // this.mine        this.willDestroy    },    mine: 12,    foo() {        this.url; // this: any because 'foo' matches the string indexer        this.willDestroy;    }} : { init(this: IndexedWithThis): void; mine: number; foo(this: any): void; }
 
     init() {
->init : () => void
+>init : (this: IndexedWithThis) => void
 
         this // this: IndexedWithThis because of contextual typing.
 >this : IndexedWithThis
@@ -78,7 +78,7 @@ extend1({
 >12 : number
 
     foo() {
->foo : () => void
+>foo : (this: any) => void
 
         this.url; // this: any because 'foo' matches the string indexer
 >this.url : any
diff --git a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json
new file mode 100644
index 0000000000000..ea891967cb510
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json	
@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json
new file mode 100644
index 0000000000000..abe135b4f1687
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json	
@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false,
+        "noUnusedLocals": true
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json
new file mode 100644
index 0000000000000..e28b66c8c2bf9
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json	
@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false,
+        "jsx": "react"
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json
new file mode 100644
index 0000000000000..5273b3cb7c8ed
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json	
@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false
+    },
+    "files": [
+        "file0.st",
+        "file1.ts",
+        "file2.ts"
+    ]
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json
new file mode 100644
index 0000000000000..fa9cb6cad8411
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json	
@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false,
+        "lib": [
+            "es5",
+            "es2015.promise"
+        ]
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json
new file mode 100644
index 0000000000000..ea891967cb510
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json	
@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json
new file mode 100644
index 0000000000000..3ff8208d9d64c
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json	
@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false,
+        "lib": [
+            "es5",
+            "es2015.core"
+        ]
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json
new file mode 100644
index 0000000000000..b1740ac4c12c3
--- /dev/null
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json	
@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "noImplicitAny": false,
+        "sourceMap": false,
+        "types": [
+            "jquery",
+            "mocha"
+        ]
+    }
+}
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxAttributeResolution14.errors.txt b/tests/baselines/reference/tsxAttributeResolution14.errors.txt
new file mode 100644
index 0000000000000..81d42e49059f6
--- /dev/null
+++ b/tests/baselines/reference/tsxAttributeResolution14.errors.txt
@@ -0,0 +1,38 @@
+tests/cases/conformance/jsx/file.tsx(14,28): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/jsx/file.tsx(16,28): error TS2322: Type 'boolean' is not assignable to type 'string | number'.
+
+
+==== tests/cases/conformance/jsx/react.d.ts (0 errors) ====
+    
+    declare module JSX {
+    	interface Element { }
+    	interface IntrinsicElements {
+            div: any;
+    	}
+        interface ElementAttributesProperty { prop: any }
+    }
+    
+==== tests/cases/conformance/jsx/file.tsx (2 errors) ====
+    
+    interface IProps {
+      primaryText: string,
+      [propName: string]: string | number
+    }
+    
+    function VerticalNavMenuItem(prop: IProps) {
+      return <div>props.primaryText</div>
+    }
+    
+    function VerticalNav() {
+      return (
+        <div>
+          <VerticalNavMenuItem primaryText={2} />  // error
+                               ~~~~~~~~~~~~~~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+          <VerticalNavMenuItem justRandomProp={2} primaryText={"hello"} />  // ok
+          <VerticalNavMenuItem justRandomProp1={true} primaryText={"hello"} />  // error
+                               ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2322: Type 'boolean' is not assignable to type 'string | number'.
+        </div>
+      )
+    } 
\ No newline at end of file
diff --git a/tests/baselines/reference/tsxAttributeResolution14.js b/tests/baselines/reference/tsxAttributeResolution14.js
new file mode 100644
index 0000000000000..d920179458cc0
--- /dev/null
+++ b/tests/baselines/reference/tsxAttributeResolution14.js
@@ -0,0 +1,47 @@
+//// [tests/cases/conformance/jsx/tsxAttributeResolution14.tsx] ////
+
+//// [react.d.ts]
+
+declare module JSX {
+	interface Element { }
+	interface IntrinsicElements {
+        div: any;
+	}
+    interface ElementAttributesProperty { prop: any }
+}
+
+//// [file.tsx]
+
+interface IProps {
+  primaryText: string,
+  [propName: string]: string | number
+}
+
+function VerticalNavMenuItem(prop: IProps) {
+  return <div>props.primaryText</div>
+}
+
+function VerticalNav() {
+  return (
+    <div>
+      <VerticalNavMenuItem primaryText={2} />  // error
+      <VerticalNavMenuItem justRandomProp={2} primaryText={"hello"} />  // ok
+      <VerticalNavMenuItem justRandomProp1={true} primaryText={"hello"} />  // error
+    </div>
+  )
+} 
+
+//// [file.jsx]
+function VerticalNavMenuItem(prop) {
+    return <div>props.primaryText</div>;
+}
+function VerticalNav() {
+    return (<div>
+      <VerticalNavMenuItem primaryText={2}/> // error
+      // error
+      <VerticalNavMenuItem justRandomProp={2} primaryText={"hello"}/> // ok
+      // ok
+      <VerticalNavMenuItem justRandomProp1={true} primaryText={"hello"}/> // error
+      // error
+    </div>);
+}
diff --git a/tests/baselines/reference/tsxDefaultImports.js b/tests/baselines/reference/tsxDefaultImports.js
new file mode 100644
index 0000000000000..e7e0a13860d83
--- /dev/null
+++ b/tests/baselines/reference/tsxDefaultImports.js
@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/tsxDefaultImports.ts] ////
+
+//// [a.ts]
+
+enum SomeEnum {
+  one,
+}
+export default class SomeClass {
+  public static E = SomeEnum;
+}
+
+//// [b.ts]
+import {default as Def} from "./a"
+let a = Def.E.one;
+
+
+//// [a.js]
+"use strict";
+var SomeEnum;
+(function (SomeEnum) {
+    SomeEnum[SomeEnum["one"] = 0] = "one";
+})(SomeEnum || (SomeEnum = {}));
+var SomeClass = (function () {
+    function SomeClass() {
+    }
+    return SomeClass;
+}());
+exports.__esModule = true;
+exports["default"] = SomeClass;
+SomeClass.E = SomeEnum;
+//// [b.js]
+"use strict";
+var a_1 = require("./a");
+var a = a_1["default"].E.one;
diff --git a/tests/baselines/reference/tsxDefaultImports.symbols b/tests/baselines/reference/tsxDefaultImports.symbols
new file mode 100644
index 0000000000000..e42392e24aafb
--- /dev/null
+++ b/tests/baselines/reference/tsxDefaultImports.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/compiler/a.ts ===
+
+enum SomeEnum {
+>SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0))
+
+  one,
+>one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15))
+}
+export default class SomeClass {
+>SomeClass : Symbol(SomeClass, Decl(a.ts, 3, 1))
+
+  public static E = SomeEnum;
+>E : Symbol(SomeClass.E, Decl(a.ts, 4, 32))
+>SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0))
+}
+
+=== tests/cases/compiler/b.ts ===
+import {default as Def} from "./a"
+>default : Symbol(Def, Decl(b.ts, 0, 8))
+>Def : Symbol(Def, Decl(b.ts, 0, 8))
+
+let a = Def.E.one;
+>a : Symbol(a, Decl(b.ts, 1, 3))
+>Def.E.one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15))
+>Def.E : Symbol(Def.E, Decl(a.ts, 4, 32))
+>Def : Symbol(Def, Decl(b.ts, 0, 8))
+>E : Symbol(Def.E, Decl(a.ts, 4, 32))
+>one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15))
+
diff --git a/tests/baselines/reference/tsxDefaultImports.types b/tests/baselines/reference/tsxDefaultImports.types
new file mode 100644
index 0000000000000..a9bdedf3efd21
--- /dev/null
+++ b/tests/baselines/reference/tsxDefaultImports.types
@@ -0,0 +1,29 @@
+=== tests/cases/compiler/a.ts ===
+
+enum SomeEnum {
+>SomeEnum : SomeEnum
+
+  one,
+>one : SomeEnum
+}
+export default class SomeClass {
+>SomeClass : SomeClass
+
+  public static E = SomeEnum;
+>E : typeof SomeEnum
+>SomeEnum : typeof SomeEnum
+}
+
+=== tests/cases/compiler/b.ts ===
+import {default as Def} from "./a"
+>default : typeof Def
+>Def : typeof Def
+
+let a = Def.E.one;
+>a : SomeEnum
+>Def.E.one : SomeEnum
+>Def.E : typeof SomeEnum
+>Def : typeof Def
+>E : typeof SomeEnum
+>one : SomeEnum
+
diff --git a/tests/baselines/reference/tupleTypes.errors.txt b/tests/baselines/reference/tupleTypes.errors.txt
index 75f413eb170f4..3b55476e4b1d5 100644
--- a/tests/baselines/reference/tupleTypes.errors.txt
+++ b/tests/baselines/reference/tupleTypes.errors.txt
@@ -4,8 +4,7 @@ tests/cases/compiler/tupleTypes.ts(14,1): error TS2322: Type 'undefined[]' is no
 tests/cases/compiler/tupleTypes.ts(15,1): error TS2322: Type '[number]' is not assignable to type '[number, string]'.
   Property '1' is missing in type '[number]'.
 tests/cases/compiler/tupleTypes.ts(17,1): error TS2322: Type '[string, number]' is not assignable to type '[number, string]'.
-  Types of property '0' are incompatible.
-    Type 'string' is not assignable to type 'number'.
+  Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/tupleTypes.ts(41,1): error TS2322: Type 'undefined[]' is not assignable to type '[number, string]'.
 tests/cases/compiler/tupleTypes.ts(47,1): error TS2322: Type '[number, string]' is not assignable to type 'number[]'.
   Types of property 'pop' are incompatible.
@@ -18,11 +17,9 @@ tests/cases/compiler/tupleTypes.ts(49,1): error TS2322: Type '[number, {}]' is n
       Type 'number | {}' is not assignable to type 'number'.
         Type '{}' is not assignable to type 'number'.
 tests/cases/compiler/tupleTypes.ts(50,1): error TS2322: Type '[number, number]' is not assignable to type '[number, string]'.
-  Types of property '1' are incompatible.
-    Type 'number' is not assignable to type 'string'.
+  Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is not assignable to type '[number, string]'.
-  Types of property '1' are incompatible.
-    Type '{}' is not assignable to type 'string'.
+  Type '{}' is not assignable to type 'string'.
 
 
 ==== tests/cases/compiler/tupleTypes.ts (9 errors) ====
@@ -53,8 +50,7 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     t = ["hello", 1];     // Error
     ~
 !!! error TS2322: Type '[string, number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'string' is not assignable to type 'number'.
+!!! error TS2322:   Type 'string' is not assignable to type 'number'.
     t = [1, "hello", 2];  // Ok
     
     var tf: [string, (x: string) => number] = ["hello", x => x.length];
@@ -104,13 +100,11 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     a1 = a2;  // Error
     ~~
 !!! error TS2322: Type '[number, number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
     a1 = a3;  // Error
     ~~
 !!! error TS2322: Type '[number, {}]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type '{}' is not assignable to type 'string'.
+!!! error TS2322:   Type '{}' is not assignable to type 'string'.
     a3 = a1;
     a3 = a2;
     
\ No newline at end of file
diff --git a/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.errors.txt b/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.errors.txt
index c574118f91dc3..b67f73288560f 100644
--- a/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.errors.txt
+++ b/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.errors.txt
@@ -1,16 +1,26 @@
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(12,10): error TS2339: Property 'bar' does not exist on type 'A'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(18,10): error TS2339: Property 'bar' does not exist on type 'A'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(33,5): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(34,10): error TS2339: Property 'bar' does not exist on type 'B<number>'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(41,10): error TS2339: Property 'bar' does not exist on type 'B<any>'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(66,10): error TS2339: Property 'bar2' does not exist on type 'C1'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(72,10): error TS2339: Property 'bar1' does not exist on type 'C1 | C2'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(73,10): error TS2339: Property 'bar2' does not exist on type 'C1 | C2'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(85,10): error TS2339: Property 'bar' does not exist on type 'D'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(91,10): error TS2339: Property 'bar' does not exist on type 'D'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(112,10): error TS2339: Property 'bar2' does not exist on type 'E1'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(118,11): error TS2339: Property 'bar1' does not exist on type 'E1 | E2'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(119,11): error TS2339: Property 'bar2' does not exist on type 'E1 | E2'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(134,11): error TS2339: Property 'foo' does not exist on type 'string | F'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(135,11): error TS2339: Property 'bar' does not exist on type 'string | F'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(160,11): error TS2339: Property 'foo2' does not exist on type 'G1'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(166,11): error TS2339: Property 'foo2' does not exist on type 'G1'.
 tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(182,11): error TS2339: Property 'bar' does not exist on type 'H'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(187,11): error TS2339: Property 'foo1' does not exist on type 'H'.
+tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts(188,11): error TS2339: Property 'foo2' does not exist on type 'H'.
 
 
-==== tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts (10 errors) ====
+==== tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts (20 errors) ====
     interface AConstructor {
         new (): A;
     }
@@ -28,9 +38,11 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj2: any;
-    if (obj2 instanceof A) { // can't narrow type from 'any'
+    if (obj2 instanceof A) {
         obj2.foo;
         obj2.bar;
+             ~~~
+!!! error TS2339: Property 'bar' does not exist on type 'A'.
     }
     
     // a construct signature with generics
@@ -54,10 +66,12 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj4: any;
-    if (obj4 instanceof B) { // can't narrow type from 'any'
+    if (obj4 instanceof B) {
         obj4.foo = "str";
         obj4.foo = 1;
         obj4.bar = "str";
+             ~~~
+!!! error TS2339: Property 'bar' does not exist on type 'B<any>'.
     }
     
     // has multiple construct signature
@@ -88,10 +102,14 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj6: any;
-    if (obj6 instanceof C) { // can't narrow type from 'any'
+    if (obj6 instanceof C) {
         obj6.foo;
         obj6.bar1;
+             ~~~~
+!!! error TS2339: Property 'bar1' does not exist on type 'C1 | C2'.
         obj6.bar2;
+             ~~~~
+!!! error TS2339: Property 'bar2' does not exist on type 'C1 | C2'.
     }
     
     // with object type literal
@@ -109,9 +127,11 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj8: any;
-    if (obj8 instanceof D) { // can't narrow type from 'any'
+    if (obj8 instanceof D) {
         obj8.foo;
         obj8.bar;
+             ~~~
+!!! error TS2339: Property 'bar' does not exist on type 'D'.
     }
     
     // a construct signature that returns a union type
@@ -138,10 +158,14 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj10: any;
-    if (obj10 instanceof E) { // can't narrow type from 'any'
+    if (obj10 instanceof E) {
         obj10.foo;
         obj10.bar1;
+              ~~~~
+!!! error TS2339: Property 'bar1' does not exist on type 'E1 | E2'.
         obj10.bar2;
+              ~~~~
+!!! error TS2339: Property 'bar2' does not exist on type 'E1 | E2'.
     }
     
     // a construct signature that returns any
@@ -165,7 +189,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj12: any;
-    if (obj12 instanceof F) { // can't narrow type from 'any'
+    if (obj12 instanceof F) {
         obj12.foo;
         obj12.bar;
     }
@@ -192,9 +216,11 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj14: any;
-    if (obj14 instanceof G) { // can't narrow type from 'any'
+    if (obj14 instanceof G) {
         obj14.foo1;
         obj14.foo2;
+              ~~~~
+!!! error TS2339: Property 'foo2' does not exist on type 'G1'.
     }
     
     // a type with a prototype that has any type
@@ -216,8 +242,24 @@ tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstru
     }
     
     var obj16: any;
-    if (obj16 instanceof H) { // can't narrow type from 'any'
+    if (obj16 instanceof H) {
         obj16.foo1;
+              ~~~~
+!!! error TS2339: Property 'foo1' does not exist on type 'H'.
         obj16.foo2;
+              ~~~~
+!!! error TS2339: Property 'foo2' does not exist on type 'H'.
+    }
+    
+    var obj17: any;
+    if (obj17 instanceof Object) { // can't narrow type from 'any' to 'Object'
+        obj17.foo1;
+        obj17.foo2;
+    }
+    
+    var obj18: any;
+    if (obj18 instanceof Function) { // can't narrow type from 'any' to 'Function'
+        obj18.foo1;
+        obj18.foo2;
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.js b/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.js
index 7e6b332447062..40ef6587e75f7 100644
--- a/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.js
+++ b/tests/baselines/reference/typeGuardsWithInstanceOfByConstructorSignature.js
@@ -14,7 +14,7 @@ if (obj1 instanceof A) { // narrowed to A.
 }
 
 var obj2: any;
-if (obj2 instanceof A) { // can't narrow type from 'any'
+if (obj2 instanceof A) {
     obj2.foo;
     obj2.bar;
 }
@@ -36,7 +36,7 @@ if (obj3 instanceof B) { // narrowed to B<number>.
 }
 
 var obj4: any;
-if (obj4 instanceof B) { // can't narrow type from 'any'
+if (obj4 instanceof B) {
     obj4.foo = "str";
     obj4.foo = 1;
     obj4.bar = "str";
@@ -68,7 +68,7 @@ if (obj5 instanceof C) { // narrowed to C1|C2.
 }
 
 var obj6: any;
-if (obj6 instanceof C) { // can't narrow type from 'any'
+if (obj6 instanceof C) {
     obj6.foo;
     obj6.bar1;
     obj6.bar2;
@@ -87,7 +87,7 @@ if (obj7 instanceof D) { // narrowed to D.
 }
 
 var obj8: any;
-if (obj8 instanceof D) { // can't narrow type from 'any'
+if (obj8 instanceof D) {
     obj8.foo;
     obj8.bar;
 }
@@ -114,7 +114,7 @@ if (obj9 instanceof E) { // narrowed to E1 | E2
 }
 
 var obj10: any;
-if (obj10 instanceof E) { // can't narrow type from 'any'
+if (obj10 instanceof E) {
     obj10.foo;
     obj10.bar1;
     obj10.bar2;
@@ -137,7 +137,7 @@ if (obj11 instanceof F) { // can't type narrowing, construct signature returns a
 }
 
 var obj12: any;
-if (obj12 instanceof F) { // can't narrow type from 'any'
+if (obj12 instanceof F) {
     obj12.foo;
     obj12.bar;
 }
@@ -162,7 +162,7 @@ if (obj13 instanceof G) { // narrowed to G1. G1 is return type of prototype prop
 }
 
 var obj14: any;
-if (obj14 instanceof G) { // can't narrow type from 'any'
+if (obj14 instanceof G) {
     obj14.foo1;
     obj14.foo2;
 }
@@ -184,10 +184,22 @@ if (obj15 instanceof H) { // narrowed to H.
 }
 
 var obj16: any;
-if (obj16 instanceof H) { // can't narrow type from 'any'
+if (obj16 instanceof H) {
     obj16.foo1;
     obj16.foo2;
 }
+
+var obj17: any;
+if (obj17 instanceof Object) { // can't narrow type from 'any' to 'Object'
+    obj17.foo1;
+    obj17.foo2;
+}
+
+var obj18: any;
+if (obj18 instanceof Function) { // can't narrow type from 'any' to 'Function'
+    obj18.foo1;
+    obj18.foo2;
+}
 
 
 //// [typeGuardsWithInstanceOfByConstructorSignature.js]
@@ -278,3 +290,13 @@ if (obj16 instanceof H) {
     obj16.foo1;
     obj16.foo2;
 }
+var obj17;
+if (obj17 instanceof Object) {
+    obj17.foo1;
+    obj17.foo2;
+}
+var obj18;
+if (obj18 instanceof Function) {
+    obj18.foo1;
+    obj18.foo2;
+}
diff --git a/tests/baselines/reference/typingsLookup2.js b/tests/baselines/reference/typingsLookup2.js
new file mode 100644
index 0000000000000..3e816526af252
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.js
@@ -0,0 +1,9 @@
+//// [tests/cases/conformance/typings/typingsLookup2.ts] ////
+
+//// [package.json]
+{ "typings": null }
+
+//// [a.ts]
+
+
+//// [a.js]
diff --git a/tests/baselines/reference/typingsLookup2.symbols b/tests/baselines/reference/typingsLookup2.symbols
new file mode 100644
index 0000000000000..7223c8589a640
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.symbols
@@ -0,0 +1,3 @@
+=== /a.ts ===
+
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup2.trace.json b/tests/baselines/reference/typingsLookup2.trace.json
new file mode 100644
index 0000000000000..0637a088a01e8
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.trace.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup2.types b/tests/baselines/reference/typingsLookup2.types
new file mode 100644
index 0000000000000..7223c8589a640
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup2.types
@@ -0,0 +1,3 @@
+=== /a.ts ===
+
+No type information for this code.
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup3.js b/tests/baselines/reference/typingsLookup3.js
new file mode 100644
index 0000000000000..b3be036b4ae85
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup3.js
@@ -0,0 +1,13 @@
+//// [tests/cases/conformance/typings/typingsLookup3.ts] ////
+
+//// [index.d.ts]
+declare var $: { x: any };
+
+//// [a.ts]
+/// <reference types="JqUeRy" />
+$.x;
+
+
+//// [a.js]
+/// <reference types="JqUeRy" />
+$.x;
diff --git a/tests/baselines/reference/typingsLookup3.symbols b/tests/baselines/reference/typingsLookup3.symbols
new file mode 100644
index 0000000000000..e641afb183b4b
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup3.symbols
@@ -0,0 +1,12 @@
+=== /a.ts ===
+/// <reference types="JqUeRy" />
+$.x;
+>$.x : Symbol(x, Decl(index.d.ts, 0, 16))
+>$ : Symbol($, Decl(index.d.ts, 0, 11))
+>x : Symbol(x, Decl(index.d.ts, 0, 16))
+
+=== /node_modules/@types/jquery/index.d.ts ===
+declare var $: { x: any };
+>$ : Symbol($, Decl(index.d.ts, 0, 11))
+>x : Symbol(x, Decl(index.d.ts, 0, 16))
+
diff --git a/tests/baselines/reference/typingsLookup3.trace.json b/tests/baselines/reference/typingsLookup3.trace.json
new file mode 100644
index 0000000000000..83b0e91d6c7c1
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup3.trace.json
@@ -0,0 +1,12 @@
+[
+    "======== Resolving type reference directive 'jquery', containing file '/a.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "File '/node_modules/@types/jquery/package.json' does not exist.",
+    "File '/node_modules/@types/jquery/index.d.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'jquery' was successfully resolved to '/node_modules/@types/jquery/index.d.ts', primary: true. ========",
+    "======== Resolving type reference directive 'jquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "File '/node_modules/@types/jquery/package.json' does not exist.",
+    "File '/node_modules/@types/jquery/index.d.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'jquery' was successfully resolved to '/node_modules/@types/jquery/index.d.ts', primary: true. ========"
+]
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup3.types b/tests/baselines/reference/typingsLookup3.types
new file mode 100644
index 0000000000000..f57a974077e06
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup3.types
@@ -0,0 +1,12 @@
+=== /a.ts ===
+/// <reference types="JqUeRy" />
+$.x;
+>$.x : any
+>$ : { x: any; }
+>x : any
+
+=== /node_modules/@types/jquery/index.d.ts ===
+declare var $: { x: any };
+>$ : { x: any; }
+>x : any
+
diff --git a/tests/baselines/reference/typingsLookup4.js b/tests/baselines/reference/typingsLookup4.js
new file mode 100644
index 0000000000000..c11bc13c6138b
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.js
@@ -0,0 +1,36 @@
+//// [tests/cases/conformance/typings/typingsLookup4.ts] ////
+
+//// [package.json]
+{ "typings": "jquery.d.ts" }
+
+//// [jquery.d.ts]
+export const j: number;
+
+//// [package.json]
+{ "typings": "kquery" }
+
+//// [kquery.d.ts]
+export const k: number;
+
+//// [package.json]
+{ "typings": "lquery" }
+
+//// [lquery.ts]
+export const l = 2;
+
+//// [a.ts]
+import { j } from "jquery";
+import { k } from "kquery";
+import { l } from "lquery";
+j + k + l;
+
+
+//// [lquery.js]
+"use strict";
+exports.l = 2;
+//// [a.js]
+"use strict";
+var jquery_1 = require("jquery");
+var kquery_1 = require("kquery");
+var lquery_1 = require("lquery");
+jquery_1.j + kquery_1.k + lquery_1.l;
diff --git a/tests/baselines/reference/typingsLookup4.symbols b/tests/baselines/reference/typingsLookup4.symbols
new file mode 100644
index 0000000000000..144548c645265
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.symbols
@@ -0,0 +1,27 @@
+=== /a.ts ===
+import { j } from "jquery";
+>j : Symbol(j, Decl(a.ts, 0, 8))
+
+import { k } from "kquery";
+>k : Symbol(k, Decl(a.ts, 1, 8))
+
+import { l } from "lquery";
+>l : Symbol(l, Decl(a.ts, 2, 8))
+
+j + k + l;
+>j : Symbol(j, Decl(a.ts, 0, 8))
+>k : Symbol(k, Decl(a.ts, 1, 8))
+>l : Symbol(l, Decl(a.ts, 2, 8))
+
+=== /node_modules/@types/jquery/jquery.d.ts ===
+export const j: number;
+>j : Symbol(j, Decl(jquery.d.ts, 0, 12))
+
+=== /node_modules/@types/kquery/kquery.d.ts ===
+export const k: number;
+>k : Symbol(k, Decl(kquery.d.ts, 0, 12))
+
+=== /node_modules/@types/lquery/lquery.ts ===
+export const l = 2;
+>l : Symbol(l, Decl(lquery.ts, 0, 12))
+
diff --git a/tests/baselines/reference/typingsLookup4.trace.json b/tests/baselines/reference/typingsLookup4.trace.json
new file mode 100644
index 0000000000000..4bca8456f5846
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.trace.json
@@ -0,0 +1,93 @@
+[
+    "======== Resolving module 'jquery' from '/a.ts'. ========",
+    "Module resolution kind is not specified, using 'NodeJs'.",
+    "Loading module 'jquery' from 'node_modules' folder.",
+    "File '/node_modules/jquery.ts' does not exist.",
+    "File '/node_modules/jquery.tsx' does not exist.",
+    "File '/node_modules/jquery.d.ts' does not exist.",
+    "File '/node_modules/jquery/package.json' does not exist.",
+    "File '/node_modules/jquery/index.ts' does not exist.",
+    "File '/node_modules/jquery/index.tsx' does not exist.",
+    "File '/node_modules/jquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/jquery.ts' does not exist.",
+    "File '/node_modules/@types/jquery.tsx' does not exist.",
+    "File '/node_modules/@types/jquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/jquery/package.json'.",
+    "'package.json' has 'typings' field 'jquery.d.ts' that references '/node_modules/@types/jquery/jquery.d.ts'.",
+    "File '/node_modules/@types/jquery/jquery.d.ts' exist - use it as a name resolution result.",
+    "Resolving real path for '/node_modules/@types/jquery/jquery.d.ts', result '/node_modules/@types/jquery/jquery.d.ts'",
+    "======== Module name 'jquery' was successfully resolved to '/node_modules/@types/jquery/jquery.d.ts'. ========",
+    "======== Resolving module 'kquery' from '/a.ts'. ========",
+    "Module resolution kind is not specified, using 'NodeJs'.",
+    "Loading module 'kquery' from 'node_modules' folder.",
+    "File '/node_modules/kquery.ts' does not exist.",
+    "File '/node_modules/kquery.tsx' does not exist.",
+    "File '/node_modules/kquery.d.ts' does not exist.",
+    "File '/node_modules/kquery/package.json' does not exist.",
+    "File '/node_modules/kquery/index.ts' does not exist.",
+    "File '/node_modules/kquery/index.tsx' does not exist.",
+    "File '/node_modules/kquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/kquery.ts' does not exist.",
+    "File '/node_modules/@types/kquery.tsx' does not exist.",
+    "File '/node_modules/@types/kquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/kquery/package.json'.",
+    "'package.json' has 'typings' field 'kquery' that references '/node_modules/@types/kquery/kquery'.",
+    "File '/node_modules/@types/kquery/kquery' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.ts' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.tsx' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.d.ts' exist - use it as a name resolution result.",
+    "Resolving real path for '/node_modules/@types/kquery/kquery.d.ts', result '/node_modules/@types/kquery/kquery.d.ts'",
+    "======== Module name 'kquery' was successfully resolved to '/node_modules/@types/kquery/kquery.d.ts'. ========",
+    "======== Resolving module 'lquery' from '/a.ts'. ========",
+    "Module resolution kind is not specified, using 'NodeJs'.",
+    "Loading module 'lquery' from 'node_modules' folder.",
+    "File '/node_modules/lquery.ts' does not exist.",
+    "File '/node_modules/lquery.tsx' does not exist.",
+    "File '/node_modules/lquery.d.ts' does not exist.",
+    "File '/node_modules/lquery/package.json' does not exist.",
+    "File '/node_modules/lquery/index.ts' does not exist.",
+    "File '/node_modules/lquery/index.tsx' does not exist.",
+    "File '/node_modules/lquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/lquery.ts' does not exist.",
+    "File '/node_modules/@types/lquery.tsx' does not exist.",
+    "File '/node_modules/@types/lquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/lquery/package.json'.",
+    "'package.json' has 'typings' field 'lquery' that references '/node_modules/@types/lquery/lquery'.",
+    "File '/node_modules/@types/lquery/lquery' does not exist.",
+    "File '/node_modules/@types/lquery/lquery.ts' exist - use it as a name resolution result.",
+    "Resolving real path for '/node_modules/@types/lquery/lquery.ts', result '/node_modules/@types/lquery/lquery.ts'",
+    "======== Module name 'lquery' was successfully resolved to '/node_modules/@types/lquery/lquery.ts'. ========",
+    "======== Resolving type reference directive 'jquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "Found 'package.json' at '/node_modules/@types/jquery/package.json'.",
+    "'package.json' has 'typings' field 'jquery.d.ts' that references '/node_modules/@types/jquery/jquery.d.ts'.",
+    "File '/node_modules/@types/jquery/jquery.d.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'jquery' was successfully resolved to '/node_modules/@types/jquery/jquery.d.ts', primary: true. ========",
+    "======== Resolving type reference directive 'kquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "Found 'package.json' at '/node_modules/@types/kquery/package.json'.",
+    "'package.json' has 'typings' field 'kquery' that references '/node_modules/@types/kquery/kquery'.",
+    "File '/node_modules/@types/kquery/kquery' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.d.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'kquery' was successfully resolved to '/node_modules/@types/kquery/kquery.d.ts', primary: true. ========",
+    "======== Resolving type reference directive 'lquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "Found 'package.json' at '/node_modules/@types/lquery/package.json'.",
+    "'package.json' has 'typings' field 'lquery' that references '/node_modules/@types/lquery/lquery'.",
+    "File '/node_modules/@types/lquery/lquery' does not exist.",
+    "File '/node_modules/@types/lquery/lquery.d.ts' does not exist.",
+    "File '/node_modules/@types/lquery/index.d.ts' does not exist.",
+    "Looking up in 'node_modules' folder, initial location '/'",
+    "File '/node_modules/lquery.ts' does not exist.",
+    "File '/node_modules/lquery.d.ts' does not exist.",
+    "File '/node_modules/lquery/package.json' does not exist.",
+    "File '/node_modules/lquery/index.ts' does not exist.",
+    "File '/node_modules/lquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/lquery.ts' does not exist.",
+    "File '/node_modules/@types/lquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/lquery/package.json'.",
+    "'package.json' has 'typings' field 'lquery' that references '/node_modules/@types/lquery/lquery'.",
+    "File '/node_modules/@types/lquery/lquery' does not exist.",
+    "File '/node_modules/@types/lquery/lquery.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'lquery' was successfully resolved to '/node_modules/@types/lquery/lquery.ts', primary: false. ========"
+]
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup4.types b/tests/baselines/reference/typingsLookup4.types
new file mode 100644
index 0000000000000..d922c7b1dfa53
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.types
@@ -0,0 +1,30 @@
+=== /a.ts ===
+import { j } from "jquery";
+>j : number
+
+import { k } from "kquery";
+>k : number
+
+import { l } from "lquery";
+>l : number
+
+j + k + l;
+>j + k + l : number
+>j + k : number
+>j : number
+>k : number
+>l : number
+
+=== /node_modules/@types/jquery/jquery.d.ts ===
+export const j: number;
+>j : number
+
+=== /node_modules/@types/kquery/kquery.d.ts ===
+export const k: number;
+>k : number
+
+=== /node_modules/@types/lquery/lquery.ts ===
+export const l = 2;
+>l : number
+>2 : number
+
diff --git a/tests/baselines/reference/unusedParameterProperty1.errors.txt b/tests/baselines/reference/unusedParameterProperty1.errors.txt
new file mode 100644
index 0000000000000..0581199313f86
--- /dev/null
+++ b/tests/baselines/reference/unusedParameterProperty1.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/compiler/unusedParameterProperty1.ts(3,25): error TS6138: Property 'used' is declared but never used.
+
+
+==== tests/cases/compiler/unusedParameterProperty1.ts (1 errors) ====
+    
+    class A {
+        constructor(private used: string) {
+                            ~~~~
+!!! error TS6138: Property 'used' is declared but never used.
+            let foge = used;
+            foge += "";
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/unusedParameterProperty1.js b/tests/baselines/reference/unusedParameterProperty1.js
new file mode 100644
index 0000000000000..d0b608a6d8796
--- /dev/null
+++ b/tests/baselines/reference/unusedParameterProperty1.js
@@ -0,0 +1,19 @@
+//// [unusedParameterProperty1.ts]
+
+class A {
+    constructor(private used: string) {
+        let foge = used;
+        foge += "";
+    }
+}
+
+
+//// [unusedParameterProperty1.js]
+var A = (function () {
+    function A(used) {
+        this.used = used;
+        var foge = used;
+        foge += "";
+    }
+    return A;
+}());
diff --git a/tests/baselines/reference/unusedParameterProperty2.errors.txt b/tests/baselines/reference/unusedParameterProperty2.errors.txt
new file mode 100644
index 0000000000000..cb3b3e9555679
--- /dev/null
+++ b/tests/baselines/reference/unusedParameterProperty2.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/compiler/unusedParameterProperty2.ts(3,25): error TS6138: Property 'used' is declared but never used.
+
+
+==== tests/cases/compiler/unusedParameterProperty2.ts (1 errors) ====
+    
+    class A {
+        constructor(private used) {
+                            ~~~~
+!!! error TS6138: Property 'used' is declared but never used.
+            let foge = used;
+            foge += "";
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/unusedParameterProperty2.js b/tests/baselines/reference/unusedParameterProperty2.js
new file mode 100644
index 0000000000000..2bb04fde088a2
--- /dev/null
+++ b/tests/baselines/reference/unusedParameterProperty2.js
@@ -0,0 +1,19 @@
+//// [unusedParameterProperty2.ts]
+
+class A {
+    constructor(private used) {
+        let foge = used;
+        foge += "";
+    }
+}
+
+
+//// [unusedParameterProperty2.js]
+var A = (function () {
+    function A(used) {
+        this.used = used;
+        var foge = used;
+        foge += "";
+    }
+    return A;
+}());
diff --git a/tests/cases/compiler/APISample_watcher.ts b/tests/cases/compiler/APISample_watcher.ts
index 34baa04c85035..07922bd35c779 100644
--- a/tests/cases/compiler/APISample_watcher.ts
+++ b/tests/cases/compiler/APISample_watcher.ts
@@ -23,7 +23,7 @@ declare var path: any;
 import * as ts from "typescript";
 
 function watch(rootFileNames: string[], options: ts.CompilerOptions) {
-    const files: ts.Map<{ version: number }> = {};
+    const files: ts.MapLike<{ version: number }> = {};
 
     // initialize the list of files
     rootFileNames.forEach(fileName => {
diff --git a/tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts b/tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts
new file mode 100644
index 0000000000000..d621cf460bcb1
--- /dev/null
+++ b/tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts
@@ -0,0 +1,18 @@
+class A { a }
+class B extends A { b }
+class C<T> extends Array<T> { c }
+declare var ara: A[];
+declare var arb: B[];
+declare var cra: C<A>;
+declare var crb: C<B>;
+declare var rra: ReadonlyArray<A>;
+declare var rrb: ReadonlyArray<B>;
+rra = ara;
+rrb = arb; // OK, Array<B> is assignable to ReadonlyArray<A>
+rra = arb;
+rrb = ara; // error: 'A' is not assignable to 'B'
+
+rra = cra;
+rra = crb; // OK, C<B> is assignable to ReadonlyArray<A>
+rrb = crb;
+rrb = cra; // error: 'A' is not assignable to 'B'
diff --git a/tests/cases/compiler/castOfAwait.ts b/tests/cases/compiler/castOfAwait.ts
new file mode 100644
index 0000000000000..fcd8f999e9fa9
--- /dev/null
+++ b/tests/cases/compiler/castOfAwait.ts
@@ -0,0 +1,8 @@
+// @target: es6
+async function f() {
+    <number> await 0;
+    typeof await 0;
+    void await 0;
+    await void <string> typeof <number> void await 0;
+    await await 0;
+}
diff --git a/tests/cases/compiler/castOfYield.ts b/tests/cases/compiler/castOfYield.ts
new file mode 100644
index 0000000000000..9a85e6b21c27d
--- /dev/null
+++ b/tests/cases/compiler/castOfYield.ts
@@ -0,0 +1,5 @@
+function* f() {
+    <number> (yield 0);
+    // Unlike await, yield is not allowed to appear in a simple unary expression.
+    <number> yield 0;
+}
diff --git a/tests/cases/compiler/controlFlowInstanceof.ts b/tests/cases/compiler/controlFlowInstanceof.ts
new file mode 100644
index 0000000000000..56f3ff97e4c8e
--- /dev/null
+++ b/tests/cases/compiler/controlFlowInstanceof.ts
@@ -0,0 +1,99 @@
+// @target: es6
+
+// Repros from #10167
+
+function f1(s: Set<string> | Set<number>) {
+    s = new Set<number>();
+    s;  // Set<number>
+    if (s instanceof Set) {
+        s;  // Set<number>
+    }
+    s;  // Set<number>
+    s.add(42);
+}
+
+function f2(s: Set<string> | Set<number>) {
+    s = new Set<number>();
+    s;  // Set<number>
+    if (s instanceof Promise) {
+        s;  // Set<number> & Promise<any>
+    }
+    s;  // Set<number>
+    s.add(42);
+}
+
+function f3(s: Set<string> | Set<number>) {
+    s;  // Set<string> | Set<number>
+    if (s instanceof Set) {
+        s;  // Set<string> | Set<number>
+    }
+    else {
+        s;  // never
+    }
+}
+
+function f4(s: Set<string> | Set<number>) {
+    s = new Set<number>();
+    s;  // Set<number>
+    if (s instanceof Set) {
+        s;  // Set<number>
+    }
+    else {
+        s;  // never
+    }
+}
+
+// More tests
+
+class A { a: string }
+class B extends A { b: string }
+class C extends A { c: string }
+
+function foo(x: A | undefined) {
+    x;  // A | undefined
+    if (x instanceof B || x instanceof C) {
+        x;  // B | C
+    }
+    x;  // A | undefined
+    if (x instanceof B && x instanceof C) {
+        x;  // B & C
+    }
+    x;  // A | undefined
+    if (!x) {
+        return;
+    }
+    x;  // A
+    if (x instanceof B) {
+        x;  // B
+        if (x instanceof C) {
+            x;  // B & C
+        }
+        else {
+            x;  // B
+        }
+        x;  // B
+    }
+    else {
+        x;  // A
+    }
+    x;  // A
+}
+
+// X is neither assignable to Y nor a subtype of Y
+// Y is assignable to X, but not a subtype of X
+
+interface X {
+    x?: string;
+}
+
+class Y {
+    y: string;
+}
+
+function goo(x: X) {
+    x;
+    if (x instanceof Y) {
+        x.y;
+    }
+    x;
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/discriminantPropertyCheck.ts b/tests/cases/compiler/discriminantPropertyCheck.ts
new file mode 100644
index 0000000000000..e493f6bf77042
--- /dev/null
+++ b/tests/cases/compiler/discriminantPropertyCheck.ts
@@ -0,0 +1,69 @@
+// @strictNullChecks: true
+
+type Item = Item1 | Item2;
+
+interface Base {
+    bar: boolean;
+}
+
+interface Item1 extends Base {
+    kind: "A";
+    foo: string | undefined;
+    baz: boolean;
+    qux: true;
+}
+
+interface Item2 extends Base {
+    kind: "B";
+    foo: string | undefined;
+    baz: boolean;
+    qux: false;
+}
+
+function goo1(x: Item) {
+    if (x.kind === "A" && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function goo2(x: Item) {
+    if (x.foo !== undefined && x.kind === "A") {
+        x.foo.length;  // Error, intervening discriminant guard
+    }
+}
+
+function foo1(x: Item) {
+    if (x.bar && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function foo2(x: Item) {
+    if (x.foo !== undefined && x.bar) {
+        x.foo.length;
+    }
+}
+
+function foo3(x: Item) {
+    if (x.baz && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function foo4(x: Item) {
+    if (x.foo !== undefined && x.baz) {
+        x.foo.length;
+    }
+}
+
+function foo5(x: Item) {
+    if (x.qux && x.foo !== undefined) {
+        x.foo.length;
+    }
+}
+
+function foo6(x: Item) {
+    if (x.foo !== undefined && x.qux) {
+        x.foo.length;  // Error, intervening discriminant guard
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/discriminantsAndNullOrUndefined.ts b/tests/cases/compiler/discriminantsAndNullOrUndefined.ts
new file mode 100644
index 0000000000000..8346fa8adeadf
--- /dev/null
+++ b/tests/cases/compiler/discriminantsAndNullOrUndefined.ts
@@ -0,0 +1,25 @@
+// @strictNullChecks: true
+
+// Repro from #10228
+
+interface A { kind: 'A'; }
+interface B { kind: 'B'; }
+
+type C = A | B | undefined;
+
+function never(_: never): never {
+    throw new Error();
+}
+
+function useA(_: A): void { }
+function useB(_: B): void { }
+
+declare var c: C;
+
+if (c !== undefined) {
+    switch (c.kind) {
+        case 'A': useA(c); break;
+        case 'B': useB(c); break;
+        default: never(c);
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/discriminantsAndPrimitives.ts b/tests/cases/compiler/discriminantsAndPrimitives.ts
new file mode 100644
index 0000000000000..6352d741808ab
--- /dev/null
+++ b/tests/cases/compiler/discriminantsAndPrimitives.ts
@@ -0,0 +1,49 @@
+// @strictNullChecks: true
+
+// Repro from #10257 plus other tests
+
+interface Foo {
+    kind: "foo";
+    name: string;
+}
+
+interface Bar {
+    kind: "bar";
+    length: string;
+}
+
+function f1(x: Foo | Bar | string) {
+    if (typeof x !== 'string') {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f2(x: Foo | Bar | string | undefined) {
+    if (typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f3(x: Foo | Bar | string | null) {
+    if (x && typeof x !== "string") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
+
+function f4(x: Foo | Bar | string | number | null) {
+    if (x && typeof x === "object") {
+        switch(x.kind) {
+            case 'foo':
+                x.name;
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/discriminantsAndTypePredicates.ts b/tests/cases/compiler/discriminantsAndTypePredicates.ts
new file mode 100644
index 0000000000000..c21ab7ec8f49a
--- /dev/null
+++ b/tests/cases/compiler/discriminantsAndTypePredicates.ts
@@ -0,0 +1,31 @@
+// Repro from #10145
+
+interface A { type: 'A' }
+interface B { type: 'B' }
+
+function isA(x: A | B): x is A { return x.type === 'A'; }
+function isB(x: A | B): x is B { return x.type === 'B'; }
+
+function foo1(x: A | B): any {
+    x;  // A | B
+    if (isA(x)) {
+        return x;  // A
+    }
+    x;  // B
+    if (isB(x)) {
+        return x;  // B
+    }
+    x;  // never
+}
+
+function foo2(x: A | B): any {
+    x;  // A | B
+    if (x.type === 'A') {
+        return x;  // A
+    }
+    x;  // B
+    if (x.type === 'B') {
+        return x;  // B
+    }
+    x;  // never
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts b/tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts
new file mode 100644
index 0000000000000..e369cd9fb505d
--- /dev/null
+++ b/tests/cases/compiler/emitCapturingThisInTupleDestructuring1.ts
@@ -0,0 +1,4 @@
+declare function wrapper(x: any);
+wrapper((array: [any]) => {
+    [this.test, this.test1, this.test2] = array;  // even though there is a compiler error, we should still emit lexical capture for "this"
+});
\ No newline at end of file
diff --git a/tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts b/tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts
new file mode 100644
index 0000000000000..2bb931c4f4f1a
--- /dev/null
+++ b/tests/cases/compiler/emitCapturingThisInTupleDestructuring2.ts
@@ -0,0 +1,10 @@
+var array1: [number, number] = [1, 2];
+
+class B {
+    test: number;
+    test1: any;
+    test2: any;
+    method() {
+        () => [this.test, this.test1, this.test2] = array1; // even though there is a compiler error, we should still emit lexical capture for "this" 
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/exportDefaultProperty.ts b/tests/cases/compiler/exportDefaultProperty.ts
new file mode 100644
index 0000000000000..4a4b413902586
--- /dev/null
+++ b/tests/cases/compiler/exportDefaultProperty.ts
@@ -0,0 +1,39 @@
+// This test is just like exportEqualsProperty, but with `export default`.
+
+// @Filename: declarations.d.ts
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export default foo.bar;
+}
+
+declare module "foobarx" {
+    export default foo.bar.X;
+}
+
+// @Filename: a.ts
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export default A.B;
+
+// @Filename: b.ts
+export default "foo".length;
+
+// @Filename: index.ts
+/// <reference path="declarations.d.ts" />
+import fooBar from "foobar";
+import X = fooBar.X;
+import X2 from "foobarx";
+const x: X = X;
+const x2: X2 = X2;
+
+import B from "./a";
+const b: B = new B(B.b);
+
+import fooLength from "./b";
+fooLength + 1;
diff --git a/tests/cases/compiler/exportDefaultProperty2.ts b/tests/cases/compiler/exportDefaultProperty2.ts
new file mode 100644
index 0000000000000..0db617c93e1ee
--- /dev/null
+++ b/tests/cases/compiler/exportDefaultProperty2.ts
@@ -0,0 +1,15 @@
+// This test is just like exportEqualsProperty2, but with `export default`.
+
+// @Filename: a.ts
+class C {
+    static B: number;
+}
+namespace C {
+    export interface B { c: number }
+}
+
+export default C.B;
+
+// @Filename: b.ts
+import B from "./a";
+const x: B = { c: B };
diff --git a/tests/cases/compiler/exportEqualsProperty.ts b/tests/cases/compiler/exportEqualsProperty.ts
new file mode 100644
index 0000000000000..0d14815a5bdf0
--- /dev/null
+++ b/tests/cases/compiler/exportEqualsProperty.ts
@@ -0,0 +1,38 @@
+// This test is just like exportDefaultProperty, but with `export =`.
+
+// @Filename: declarations.d.ts
+declare namespace foo.bar {
+    export type X = number;
+    export const X: number;
+}
+
+declare module "foobar" {
+    export = foo.bar;
+}
+
+declare module "foobarx" {
+    export = foo.bar.X;
+}
+
+// @Filename: a.ts
+namespace A {
+    export class B { constructor(b: number) {} }
+    export namespace B { export const b: number = 0; }
+}
+export = A.B;
+
+// @Filename: b.ts
+export = "foo".length;
+
+// @Filename: index.ts
+/// <reference path="declarations.d.ts" />
+import { X } from "foobar";
+import X2 = require("foobarx");
+const x: X = X;
+const x2: X2 = X2;
+
+import B = require("./a");
+const b: B = new B(B.b);
+
+import fooLength = require("./b");
+fooLength + 1;
diff --git a/tests/cases/compiler/exportEqualsProperty2.ts b/tests/cases/compiler/exportEqualsProperty2.ts
new file mode 100644
index 0000000000000..61f117f162938
--- /dev/null
+++ b/tests/cases/compiler/exportEqualsProperty2.ts
@@ -0,0 +1,15 @@
+// This test is just like exportDefaultProperty2, but with `export =`.
+
+// @Filename: a.ts
+class C {
+    static B: number;
+}
+namespace C {
+    export interface B { c: number }
+}
+
+export = C.B;
+
+// @Filename: b.ts
+import B = require("./a");
+const x: B = { c: B };
diff --git a/tests/cases/compiler/getterControlFlowStrictNull.ts b/tests/cases/compiler/getterControlFlowStrictNull.ts
new file mode 100644
index 0000000000000..44fbe35978942
--- /dev/null
+++ b/tests/cases/compiler/getterControlFlowStrictNull.ts
@@ -0,0 +1,20 @@
+//@strictNullChecks: true
+//@target: ES5
+class A {
+   a(): string | null {
+        if (Math.random() > 0.5) {
+            return '';
+        }
+
+        // it does error here as expected
+    }
+}
+class B {
+    get a(): string | null {
+        if (Math.random() > 0.5) {
+            return '';
+        }
+
+        // it should error here because it returns undefined
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/implicitConstParameters.ts b/tests/cases/compiler/implicitConstParameters.ts
new file mode 100644
index 0000000000000..97996789124f6
--- /dev/null
+++ b/tests/cases/compiler/implicitConstParameters.ts
@@ -0,0 +1,57 @@
+// @strictNullChecks: true
+
+function doSomething(cb: () => void) {
+    cb();
+}
+
+function fn(x: number | string) {
+  if (typeof x === 'number') {
+      doSomething(() => x.toFixed());
+  }
+}
+
+function f1(x: string | undefined) {
+    if (!x) {
+        return;
+    }
+    doSomething(() => x.length);
+}
+
+function f2(x: string | undefined) {
+    if (x) {
+        doSomething(() => {
+            doSomething(() => x.length);
+        });
+    }
+}
+
+function f3(x: string | undefined) {
+    inner();
+    function inner() {
+        if (x) {
+            doSomething(() => x.length);
+        }
+    }
+}
+
+function f4(x: string | undefined) {
+    x = "abc";  // causes x to be considered non-const
+    if (x) {
+        doSomething(() => x.length);
+    }
+}
+
+function f5(x: string | undefined) {
+    if (x) {
+        doSomething(() => x.length);
+    }
+    x = "abc";  // causes x to be considered non-const
+}
+
+
+function f6(x: string | undefined) {
+    const y = x || "";
+    if (x) {
+        doSomething(() => y.length);
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/indexWithUndefinedAndNull.ts b/tests/cases/compiler/indexWithUndefinedAndNull.ts
new file mode 100644
index 0000000000000..2aeb2ee0b1dc0
--- /dev/null
+++ b/tests/cases/compiler/indexWithUndefinedAndNull.ts
@@ -0,0 +1,13 @@
+// @strictNullChecks: false
+interface N {
+    [n: number]: string;
+}
+interface S {
+    [s: string]: number;
+}
+let n: N;
+let s: S;
+let str: string = n[undefined];
+str = n[null];
+let num: number = s[undefined];
+num = s[null];
diff --git a/tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts b/tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts
new file mode 100644
index 0000000000000..f8fe0a323c660
--- /dev/null
+++ b/tests/cases/compiler/indexWithUndefinedAndNullStrictNullChecks.ts
@@ -0,0 +1,13 @@
+// @strictNullChecks: true
+interface N {
+    [n: number]: string;
+}
+interface S {
+    [s: string]: number;
+}
+let n: N;
+let s: S;
+let str: string = n[undefined];
+str = n[null];
+let num: number = s[undefined];
+num = s[null];
diff --git a/tests/cases/compiler/instanceofWithStructurallyIdenticalTypes.ts b/tests/cases/compiler/instanceofWithStructurallyIdenticalTypes.ts
new file mode 100644
index 0000000000000..564f7a9c22eaa
--- /dev/null
+++ b/tests/cases/compiler/instanceofWithStructurallyIdenticalTypes.ts
@@ -0,0 +1,69 @@
+// Repro from #7271
+
+class C1 { item: string }
+class C2 { item: string[] }
+class C3 { item: string }
+
+function foo1(x: C1 | C2 | C3): string {
+    if (x instanceof C1) {
+        return x.item;
+    }
+    else if (x instanceof C2) {
+        return x.item[0];
+    }
+    else if (x instanceof C3) {
+        return x.item;
+    }
+    return "error";
+}
+
+function isC1(c: C1 | C2 | C3): c is C1 { return c instanceof C1 }
+function isC2(c: C1 | C2 | C3): c is C2 { return c instanceof C2 }
+function isC3(c: C1 | C2 | C3): c is C3 { return c instanceof C3 }
+
+function foo2(x: C1 | C2 | C3): string {
+    if (isC1(x)) {
+        return x.item;
+    }
+    else if (isC2(x)) {
+        return x.item[0];
+    }
+    else if (isC3(x)) {
+        return x.item;
+    }
+    return "error";
+}
+
+// More tests
+
+class A { a: string }
+class A1 extends A { }
+class A2 { a: string }
+class B extends A { b: string }
+
+function goo(x: A) {
+    if (x instanceof A) {
+        x;  // A
+    }
+    else {
+        x;  // never
+    }
+    if (x instanceof A1) {
+        x;  // A1
+    }
+    else {
+        x;  // A
+    }
+    if (x instanceof A2) {
+        x;  // A2
+    }
+    else {
+        x;  // A
+    }
+    if (x instanceof B) {
+        x;  // B
+    }
+    else {
+        x;  // A
+    }
+}
diff --git a/tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts b/tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts
new file mode 100644
index 0000000000000..f06f06ee7a1c5
--- /dev/null
+++ b/tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts
@@ -0,0 +1,11 @@
+interface JQuery {
+    each<T>(
+        collection: T[], callback: (this: T, dit: T) => T
+    ): T[];
+}
+
+let $: JQuery;
+let lines: string[];
+$.each(lines, function(dit) {
+    return dit.charAt(0) + this.charAt(1);
+});
diff --git a/tests/cases/compiler/missingFunctionImplementation2.ts b/tests/cases/compiler/missingFunctionImplementation2.ts
index 25909b6add4c2..1717bc663f270 100644
--- a/tests/cases/compiler/missingFunctionImplementation2.ts
+++ b/tests/cases/compiler/missingFunctionImplementation2.ts
@@ -1,6 +1,6 @@
 // @Filename: missingFunctionImplementation2_a.ts
 export {};
-declare module "./missingFunctionImplementation2_b.ts" {
+declare module "./missingFunctionImplementation2_b" {
   export function f(a, b): void;
 }
 
diff --git a/tests/cases/compiler/moduleResolutionNoTs.ts b/tests/cases/compiler/moduleResolutionNoTs.ts
new file mode 100644
index 0000000000000..2051bc259bf0e
--- /dev/null
+++ b/tests/cases/compiler/moduleResolutionNoTs.ts
@@ -0,0 +1,19 @@
+// @filename: x.ts
+export default 0;
+
+// @filename: y.tsx
+export default 0;
+
+// @filename: z.d.ts
+declare const x: number;
+export default x;
+
+// @filename: user.ts
+import x from "./x.ts";
+import y from "./y.tsx";
+import z from "./z.d.ts";
+
+// Making sure the suggested fixes are valid:
+import x2 from "./x";
+import y2 from "./y";
+import z2 from "./z";
diff --git a/tests/cases/compiler/nativeToBoxedTypes.ts b/tests/cases/compiler/nativeToBoxedTypes.ts
new file mode 100644
index 0000000000000..a34dd5cdd3b1d
--- /dev/null
+++ b/tests/cases/compiler/nativeToBoxedTypes.ts
@@ -0,0 +1,15 @@
+var N = new Number();
+var n = 100;
+n = N;
+
+var S = new String();
+var s = "foge";
+s = S;
+
+var B = new Boolean();
+var b = true;
+b = B;
+
+var sym: symbol; 
+var Sym: Symbol;
+sym = Sym;
\ No newline at end of file
diff --git a/tests/cases/compiler/nestedLoopTypeGuards.ts b/tests/cases/compiler/nestedLoopTypeGuards.ts
new file mode 100644
index 0000000000000..90d7912dec532
--- /dev/null
+++ b/tests/cases/compiler/nestedLoopTypeGuards.ts
@@ -0,0 +1,31 @@
+// Repros from #10378
+
+function f1() {
+    var a: boolean | number | string;
+    if (typeof a !== 'boolean') {
+        // a is narrowed to "number | string"
+        for (var i = 0; i < 1; i++) {
+            for (var j = 0; j < 1; j++) {}
+            if (typeof a === 'string') {
+                // a is narrowed to "string'
+                for (var j = 0; j < 1; j++) {
+                    a.length; // Should not error here
+                }
+            }
+        }
+    }
+}
+
+function f2() {
+    var a: string | number;
+    if (typeof a === 'string') {
+        while (1) {
+            while (1) {}
+            if (typeof a === 'string') {
+                while (1) {
+                    a.length; // Should not error here
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/noErrorTruncation.ts b/tests/cases/compiler/noErrorTruncation.ts
new file mode 100644
index 0000000000000..5bd6ecf1d74a7
--- /dev/null
+++ b/tests/cases/compiler/noErrorTruncation.ts
@@ -0,0 +1,15 @@
+// @noErrorTruncation
+
+type SomeLongOptionA = { someLongOptionA: string }
+type SomeLongOptionB = { someLongOptionB: string }
+type SomeLongOptionC = { someLongOptionC: string }
+type SomeLongOptionD = { someLongOptionD: string }
+type SomeLongOptionE = { someLongOptionE: string }
+type SomeLongOptionF = { someLongOptionF: string }
+
+const x: SomeLongOptionA
+       | SomeLongOptionB
+       | SomeLongOptionC
+       | SomeLongOptionD
+       | SomeLongOptionE
+       | SomeLongOptionF = 42;
diff --git a/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts b/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts
index 6988416d4de3f..ea99d03bd7cc5 100644
--- a/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts
+++ b/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration.ts
@@ -7,4 +7,6 @@ var [a2]: [any], {b2}: { b2: any }, c2: any, d2: any;
 
 var {b3}: { b3 }, c3: { b3 }; // error in type instead
 
-var [a1] = [undefined], {b1} = { b1: null }, c1 = undefined, d1 = null; // error
\ No newline at end of file
+var [a4] = [undefined], {b4} = { b4: null }, c4 = undefined, d4 = null; // error
+
+var [a5 = undefined] = []; // error
\ No newline at end of file
diff --git a/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts b/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts
new file mode 100644
index 0000000000000..a964bd96dba0d
--- /dev/null
+++ b/tests/cases/compiler/noImplicitAnyDestructuringVarDeclaration2.ts
@@ -0,0 +1,12 @@
+// @noimplicitany: true
+let [a, b, c] = [1, 2, 3]; // no error
+let [a1 = 10, b1 = 10, c1 = 10] = [1, 2, 3]; // no error
+let [a2 = undefined, b2 = undefined, c2 = undefined] = [1, 2, 3]; // no error
+let [a3 = <any>undefined, b3 = <any>null, c3 = <any>undefined] = [1, 2, 3]; // no error
+let [a4] = [<any>undefined], [b4] = [<any>null], c4 = <any>undefined, d4 = <any>null; // no error
+
+let {x, y, z} = { x: 1, y: 2, z: 3 }; // no error
+let {x1 = 10, y1 = 10, z1 = 10} = { x1: 1, y1: 2, z1: 3 }; // no error
+let {x2 = undefined, y2 = undefined, z2 = undefined} = { x2: 1, y2: 2, z2: 3 }; // no error
+let {x3 = <any>undefined, y3 = <any>null, z3 = <any>undefined} = { x3: 1, y3: 2, z3: 3 }; // no error
+let {x4} = { x4: <any>undefined }, {y4} = { y4: <any>null }; // no error
diff --git a/tests/cases/compiler/staticInstanceResolution5.ts b/tests/cases/compiler/staticInstanceResolution5.ts
index 3adb8667be578..ed34dbd535f27 100644
--- a/tests/cases/compiler/staticInstanceResolution5.ts
+++ b/tests/cases/compiler/staticInstanceResolution5.ts
@@ -7,7 +7,7 @@ export class Promise {
 }
 
 // @Filename: staticInstanceResolution5_1.ts
-import WinJS = require('staticInstanceResolution5_0.ts');
+import WinJS = require('staticInstanceResolution5_0');
 
 // these 3 should be errors
 var x = (w1: WinJS) => { };
diff --git a/tests/cases/compiler/thisInTupleTypeParameterConstraints.ts b/tests/cases/compiler/thisInTupleTypeParameterConstraints.ts
new file mode 100644
index 0000000000000..b6d0d338d85c5
--- /dev/null
+++ b/tests/cases/compiler/thisInTupleTypeParameterConstraints.ts
@@ -0,0 +1,22 @@
+/// <reference no-default-lib="true"/>
+
+interface Boolean {}
+interface IArguments {}
+interface Function {}
+interface Number {}
+interface RegExp {}
+interface Object {}
+interface String {}
+
+interface Array<T> {
+    // 4 methods will run out of memory if this-types are not instantiated
+    // correctly for tuple types that are type parameter constraints
+    map<U>(arg: this): void;
+    reduceRight<U>(arg: this): void;
+    reduce<U>(arg: this): void;
+    reduce2<U>(arg: this): void;
+}
+
+declare function f<T extends [(x: number) => number]>(a: T): void;
+let x: [(x: number) => number];
+f(x);
diff --git a/tests/cases/compiler/tsxDefaultImports.ts b/tests/cases/compiler/tsxDefaultImports.ts
new file mode 100644
index 0000000000000..4e313b33eac78
--- /dev/null
+++ b/tests/cases/compiler/tsxDefaultImports.ts
@@ -0,0 +1,12 @@
+// @Filename: a.ts
+
+enum SomeEnum {
+  one,
+}
+export default class SomeClass {
+  public static E = SomeEnum;
+}
+
+// @Filename: b.ts
+import {default as Def} from "./a"
+let a = Def.E.one;
diff --git a/tests/cases/compiler/unusedParameterProperty1.ts b/tests/cases/compiler/unusedParameterProperty1.ts
new file mode 100644
index 0000000000000..61c4374c60a33
--- /dev/null
+++ b/tests/cases/compiler/unusedParameterProperty1.ts
@@ -0,0 +1,9 @@
+//@noUnusedLocals:true
+//@noUnusedParameters:true
+
+class A {
+    constructor(private used: string) {
+        let foge = used;
+        foge += "";
+    }
+}
diff --git a/tests/cases/compiler/unusedParameterProperty2.ts b/tests/cases/compiler/unusedParameterProperty2.ts
new file mode 100644
index 0000000000000..b9e05fbc96700
--- /dev/null
+++ b/tests/cases/compiler/unusedParameterProperty2.ts
@@ -0,0 +1,9 @@
+//@noUnusedLocals:true
+//@noUnusedParameters:true
+
+class A {
+    constructor(private used) {
+        let foge = used;
+        foge += "";
+    }
+}
diff --git a/tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts b/tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts
deleted file mode 100644
index bf7de709ef28e..0000000000000
--- a/tests/cases/conformance/ambient/ambientShorthand_isImplicitAny.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-// @noImplicitAny: true
-declare module "jquery";
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6.ts
new file mode 100644
index 0000000000000..09cf0a87a5adc
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6.ts
@@ -0,0 +1,17 @@
+// @target: es6
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    +await 42; // OK
+}
+
+async function bar3() {
+    -await 42; // OK
+}
+
+async function bar4() {
+    ~await 42; // OK
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts
new file mode 100644
index 0000000000000..5ccf1a1c35a87
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts
@@ -0,0 +1,21 @@
+// @target: es6
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    delete await 42; // OK
+}
+
+async function bar2() {
+    delete await 42; // OK
+}
+
+async function bar3() {
+    void await 42;
+}
+
+async function bar4() {
+    +await 42;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts
new file mode 100644
index 0000000000000..24683765d1996
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts
@@ -0,0 +1,13 @@
+// @target: es6
+
+async function bar1() {
+    delete await 42;
+}
+
+async function bar2() {
+    delete await 42;
+}
+
+async function bar3() {
+    void await 42;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts
new file mode 100644
index 0000000000000..b595ab5e748ad
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts
@@ -0,0 +1,19 @@
+// @target: es6
+
+async function bar1() {
+    ++await 42; // Error
+}
+
+async function bar2() {
+    --await 42; // Error
+}
+
+async function bar3() {
+    var x = 42;
+    await x++; // OK but shouldn't need parenthesis
+}
+
+async function bar4() {
+    var x = 42;
+    await x--; // OK but shouldn't need parenthesis
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/controlFlow/controlFlowIfStatement.ts b/tests/cases/conformance/controlFlow/controlFlowIfStatement.ts
index c9e9be92f8e7e..dc1cf97fe5991 100644
--- a/tests/cases/conformance/controlFlow/controlFlowIfStatement.ts
+++ b/tests/cases/conformance/controlFlow/controlFlowIfStatement.ts
@@ -34,3 +34,19 @@ function b() {
     }
     x; // string
 }
+function c<T>(data: string | T): T {
+    if (typeof data === 'string') {
+        return JSON.parse(data);
+    }
+    else {
+        return data;
+    }
+}
+function d<T extends string>(data: string | T): never {
+    if (typeof data === 'string') {
+        throw new Error('will always happen');
+    }
+    else {
+        return data;
+    }
+}
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts
index b81dd26652b0e..0817954c35c5c 100644
--- a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithInstanceOfByConstructorSignature.ts
@@ -13,7 +13,7 @@ if (obj1 instanceof A) { // narrowed to A.
 }
 
 var obj2: any;
-if (obj2 instanceof A) { // can't narrow type from 'any'
+if (obj2 instanceof A) {
     obj2.foo;
     obj2.bar;
 }
@@ -35,7 +35,7 @@ if (obj3 instanceof B) { // narrowed to B<number>.
 }
 
 var obj4: any;
-if (obj4 instanceof B) { // can't narrow type from 'any'
+if (obj4 instanceof B) {
     obj4.foo = "str";
     obj4.foo = 1;
     obj4.bar = "str";
@@ -67,7 +67,7 @@ if (obj5 instanceof C) { // narrowed to C1|C2.
 }
 
 var obj6: any;
-if (obj6 instanceof C) { // can't narrow type from 'any'
+if (obj6 instanceof C) {
     obj6.foo;
     obj6.bar1;
     obj6.bar2;
@@ -86,7 +86,7 @@ if (obj7 instanceof D) { // narrowed to D.
 }
 
 var obj8: any;
-if (obj8 instanceof D) { // can't narrow type from 'any'
+if (obj8 instanceof D) {
     obj8.foo;
     obj8.bar;
 }
@@ -113,7 +113,7 @@ if (obj9 instanceof E) { // narrowed to E1 | E2
 }
 
 var obj10: any;
-if (obj10 instanceof E) { // can't narrow type from 'any'
+if (obj10 instanceof E) {
     obj10.foo;
     obj10.bar1;
     obj10.bar2;
@@ -136,7 +136,7 @@ if (obj11 instanceof F) { // can't type narrowing, construct signature returns a
 }
 
 var obj12: any;
-if (obj12 instanceof F) { // can't narrow type from 'any'
+if (obj12 instanceof F) {
     obj12.foo;
     obj12.bar;
 }
@@ -161,7 +161,7 @@ if (obj13 instanceof G) { // narrowed to G1. G1 is return type of prototype prop
 }
 
 var obj14: any;
-if (obj14 instanceof G) { // can't narrow type from 'any'
+if (obj14 instanceof G) {
     obj14.foo1;
     obj14.foo2;
 }
@@ -183,7 +183,19 @@ if (obj15 instanceof H) { // narrowed to H.
 }
 
 var obj16: any;
-if (obj16 instanceof H) { // can't narrow type from 'any'
+if (obj16 instanceof H) {
     obj16.foo1;
     obj16.foo2;
 }
+
+var obj17: any;
+if (obj17 instanceof Object) { // can't narrow type from 'any' to 'Object'
+    obj17.foo1;
+    obj17.foo2;
+}
+
+var obj18: any;
+if (obj18 instanceof Function) { // can't narrow type from 'any' to 'Function'
+    obj18.foo1;
+    obj18.foo2;
+}
diff --git a/tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts b/tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts
index 6ad3565862337..429289546c5ea 100644
--- a/tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts
+++ b/tests/cases/conformance/externalModules/moduleResolutionWithExtensions.ts
@@ -7,10 +7,6 @@ export default 0;
 // @Filename: /src/b.ts
 import a from './a';
 
-// Matching extension
-// @Filename: /src/c.ts
-import a from './a.ts';
-
 // '.js' extension: stripped and replaced with '.ts'
 // @Filename: /src/d.ts
 import a from './a.js';
diff --git a/tests/cases/conformance/jsdoc/jsdocLiteral.ts b/tests/cases/conformance/jsdoc/jsdocLiteral.ts
new file mode 100644
index 0000000000000..bd0d2d562f9a5
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/jsdocLiteral.ts
@@ -0,0 +1,13 @@
+// @allowJs: true
+// @filename: in.js
+// @out: out.js
+/**
+ * @param {'literal'} p1
+ * @param {"literal"} p2
+ * @param {'literal' | 'other'} p3
+ * @param {'literal' | number} p4
+ * @param {12 | true | 'str'} p5
+ */
+function f(p1, p2, p3, p4, p5) {
+    return p1 + p2 + p3 + p4 + p5 + '.';
+}
diff --git a/tests/cases/conformance/jsdoc/jsdocNeverUndefinedNull.ts b/tests/cases/conformance/jsdoc/jsdocNeverUndefinedNull.ts
new file mode 100644
index 0000000000000..c095bc1c920d4
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/jsdocNeverUndefinedNull.ts
@@ -0,0 +1,11 @@
+// @allowJs: true
+// @filename: in.js
+// @out: out.js
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+}
diff --git a/tests/cases/conformance/jsx/tsxAttributeResolution14.tsx b/tests/cases/conformance/jsx/tsxAttributeResolution14.tsx
new file mode 100644
index 0000000000000..1e4418e7fba37
--- /dev/null
+++ b/tests/cases/conformance/jsx/tsxAttributeResolution14.tsx
@@ -0,0 +1,32 @@
+//@jsx: preserve
+//@module: amd
+
+//@filename: react.d.ts
+declare module JSX {
+	interface Element { }
+	interface IntrinsicElements {
+        div: any;
+	}
+    interface ElementAttributesProperty { prop: any }
+}
+
+//@filename: file.tsx
+
+interface IProps {
+  primaryText: string,
+  [propName: string]: string | number
+}
+
+function VerticalNavMenuItem(prop: IProps) {
+  return <div>props.primaryText</div>
+}
+
+function VerticalNav() {
+  return (
+    <div>
+      <VerticalNavMenuItem primaryText={2} />  // error
+      <VerticalNavMenuItem justRandomProp={2} primaryText={"hello"} />  // ok
+      <VerticalNavMenuItem justRandomProp1={true} primaryText={"hello"} />  // error
+    </div>
+  )
+} 
\ No newline at end of file
diff --git a/tests/cases/conformance/salsa/multipleDeclarations.ts b/tests/cases/conformance/salsa/multipleDeclarations.ts
index 6899be2ec89a2..ba2e14e11e934 100644
--- a/tests/cases/conformance/salsa/multipleDeclarations.ts
+++ b/tests/cases/conformance/salsa/multipleDeclarations.ts
@@ -1,10 +1,37 @@
 // @filename: input.js
 // @out: output.js
 // @allowJs: true
-
 function C() {
     this.m = null;
 }
 C.prototype.m = function() {
     this.nothing();
-};
+}
+class X {
+    constructor() {
+        this.m = this.m.bind(this);
+        this.mistake = 'frankly, complete nonsense';
+    }
+    m() {
+    }
+    mistake() {
+    }
+}
+let x = new X();
+X.prototype.mistake = false;
+x.m();
+x.mistake;
+class Y {
+    mistake() {
+    }
+    m() {
+    }
+    constructor() {
+        this.m = this.m.bind(this);
+        this.mistake = 'even more nonsense';
+    }
+}
+Y.prototype.mistake = true;
+let y = new Y();
+y.m();
+y.mistake();
diff --git a/tests/cases/conformance/types/any/narrowExceptionVariableInCatchClause.ts b/tests/cases/conformance/types/any/narrowExceptionVariableInCatchClause.ts
new file mode 100644
index 0000000000000..dfa60a415f91a
--- /dev/null
+++ b/tests/cases/conformance/types/any/narrowExceptionVariableInCatchClause.ts
@@ -0,0 +1,23 @@
+declare function isFooError(x: any): x is { type: 'foo'; dontPanic(); };
+
+function tryCatch() {
+    try {
+        // do stuff...
+    }
+    catch (err) { // err is implicitly 'any' and cannot be annotated
+
+        if (isFooError(err)) {
+            err.dontPanic(); // OK
+            err.doPanic(); // ERROR: Property 'doPanic' does not exist on type '{...}'
+        }
+
+        else if (err instanceof Error) {
+            err.message;
+            err.massage; // ERROR: Property 'massage' does not exist on type 'Error'
+        }
+
+        else {
+            throw err;
+        }
+    }
+}
diff --git a/tests/cases/conformance/types/any/narrowFromAnyWithInstanceof.ts b/tests/cases/conformance/types/any/narrowFromAnyWithInstanceof.ts
new file mode 100644
index 0000000000000..4fbfc46060a80
--- /dev/null
+++ b/tests/cases/conformance/types/any/narrowFromAnyWithInstanceof.ts
@@ -0,0 +1,23 @@
+declare var x: any;
+
+if (x instanceof Function) { // 'any' is not narrowed when target type is 'Function'
+    x();
+    x(1, 2, 3);
+    x("hello!");
+    x.prop;
+}
+
+if (x instanceof Object) { // 'any' is not narrowed when target type is 'Object'
+    x.method();
+    x();
+}
+
+if (x instanceof Error) { // 'any' is narrowed to types other than 'Function'/'Object'
+    x.message;
+    x.mesage;
+}
+
+if (x instanceof Date) {
+    x.getDate();
+    x.getHuors();
+}
diff --git a/tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts b/tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts
new file mode 100644
index 0000000000000..473bd349b5f91
--- /dev/null
+++ b/tests/cases/conformance/types/any/narrowFromAnyWithTypePredicate.ts
@@ -0,0 +1,34 @@
+declare var x: any;
+declare function isFunction(x): x is Function;
+declare function isObject(x): x is Object;
+declare function isAnything(x): x is {};
+declare function isError(x): x is Error;
+declare function isDate(x): x is Date;
+
+
+if (isFunction(x)) { // 'any' is not narrowed when target type is 'Function'
+    x();
+    x(1, 2, 3);
+    x("hello!");
+    x.prop;
+}
+
+if (isObject(x)) { // 'any' is not narrowed when target type is 'Object'
+    x.method();
+    x();
+}
+
+if (isAnything(x)) { // 'any' is narrowed to types other than 'Function'/'Object' (including {})
+    x.method();
+    x();
+}
+
+if (isError(x)) { 
+    x.message;
+    x.mesage;
+}
+
+if (isDate(x)) {
+    x.getDate();
+    x.getHuors();
+}
diff --git a/tests/cases/conformance/typings/typingsLookup2.ts b/tests/cases/conformance/typings/typingsLookup2.ts
new file mode 100644
index 0000000000000..90e1e463f0ab3
--- /dev/null
+++ b/tests/cases/conformance/typings/typingsLookup2.ts
@@ -0,0 +1,13 @@
+// @traceResolution: true
+// @noImplicitReferences: true
+// @currentDirectory: /
+// This tests that an @types package with `"typings": null` is not automatically included.
+// (If it were, this test would break because there are no typings to be found.)
+
+// @filename: /tsconfig.json
+{}
+
+// @filename: /node_modules/@types/angular2/package.json
+{ "typings": null }
+
+// @filename: /a.ts
diff --git a/tests/cases/conformance/typings/typingsLookup3.ts b/tests/cases/conformance/typings/typingsLookup3.ts
new file mode 100644
index 0000000000000..a0bb15476b982
--- /dev/null
+++ b/tests/cases/conformance/typings/typingsLookup3.ts
@@ -0,0 +1,14 @@
+// @traceResolution: true
+// @noImplicitReferences: true
+// @currentDirectory: /
+// This tests that `types` references are automatically lowercased.
+
+// @filename: /tsconfig.json
+{ "files": "a.ts" }
+
+// @filename: /node_modules/@types/jquery/index.d.ts
+declare var $: { x: any };
+
+// @filename: /a.ts
+/// <reference types="JqUeRy" />
+$.x;
diff --git a/tests/cases/conformance/typings/typingsLookup4.ts b/tests/cases/conformance/typings/typingsLookup4.ts
new file mode 100644
index 0000000000000..234090aebad52
--- /dev/null
+++ b/tests/cases/conformance/typings/typingsLookup4.ts
@@ -0,0 +1,31 @@
+// @traceResolution: true
+// @noImplicitReferences: true
+// @currentDirectory: /
+// A file extension is optional in typings entries.
+
+// @filename: /tsconfig.json
+{}
+
+// @filename: /node_modules/@types/jquery/package.json
+{ "typings": "jquery.d.ts" }
+
+// @filename: /node_modules/@types/jquery/jquery.d.ts
+export const j: number;
+
+// @filename: /node_modules/@types/kquery/package.json
+{ "typings": "kquery" }
+
+// @filename: /node_modules/@types/kquery/kquery.d.ts
+export const k: number;
+
+// @filename: /node_modules/@types/lquery/package.json
+{ "typings": "lquery" }
+
+// @filename: /node_modules/@types/lquery/lquery.ts
+export const l = 2;
+
+// @filename: /a.ts
+import { j } from "jquery";
+import { k } from "kquery";
+import { l } from "lquery";
+j + k + l;
diff --git a/tests/cases/fourslash/completionForStringLiteral4.ts b/tests/cases/fourslash/completionForStringLiteral4.ts
new file mode 100644
index 0000000000000..11ae699eab8d8
--- /dev/null
+++ b/tests/cases/fourslash/completionForStringLiteral4.ts
@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts'/>
+// @allowJs: true
+// @Filename: in.js
+/////** I am documentation
+//// * @param {'literal'} p1
+//// * @param {"literal"} p2
+//// * @param {'other1' | 'other2'} p3
+//// * @param {'literal' | number} p4
+//// * @param {12 | true} p5
+//// */
+////function f(p1, p2, p3, p4, p5) {
+////    return p1 + p2 + p3 + p4 + p5 + '.';
+////}
+////f/*1*/('literal', 'literal', "o/*2*/ther1", 12);
+
+goTo.marker('1');
+verify.quickInfoExists();
+verify.quickInfoIs('function f(p1: "literal", p2: "literal", p3: "other1" | "other2", p4: number | "literal", p5: true | 12): string', 'I am documentation');
+
+goTo.marker('2');
+verify.completionListContains("other1");
+verify.completionListContains("other2");
+verify.memberListCount(2);
diff --git a/tests/cases/fourslash/completionListInObjectLiteral4.ts b/tests/cases/fourslash/completionListInObjectLiteral4.ts
new file mode 100644
index 0000000000000..c00462c8255c9
--- /dev/null
+++ b/tests/cases/fourslash/completionListInObjectLiteral4.ts
@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts'/>
+
+// @strictNullChecks: true
+////interface Thing {
+////    hello: number;
+////    world: string;
+////}
+////
+////declare function funcA(x : Thing): void;
+////declare function funcB(x?: Thing): void;
+////declare function funcC(x : Thing | null): void;
+////declare function funcD(x : Thing | undefined): void;
+////declare function funcE(x : Thing | null | undefined): void;
+////declare function funcF(x?: Thing | null | undefined): void;
+////
+////funcA({ /*A*/ });
+////funcB({ /*B*/ });
+////funcC({ /*C*/ });
+////funcD({ /*D*/ });
+////funcE({ /*E*/ });
+////funcF({ /*F*/ });
+
+
+for (const marker of test.markers()) {
+    goTo.position(marker.position);
+    verify.completionListContains("hello");
+    verify.completionListContains("world");
+}
diff --git a/tests/cases/fourslash/javaScriptClass1.ts b/tests/cases/fourslash/javaScriptClass1.ts
new file mode 100644
index 0000000000000..19f7a39b6150d
--- /dev/null
+++ b/tests/cases/fourslash/javaScriptClass1.ts
@@ -0,0 +1,31 @@
+///<reference path="fourslash.ts" />
+
+// Classes have their shape inferred from assignments
+// to properties of 'this' in the constructor
+
+// @allowNonTsExtensions: true
+// @Filename: Foo.js
+//// class Foo {
+////    constructor() {
+////        this.bar = 'world';
+////        this.thing = () => 0;
+////        this.union = 'foo';
+////        this.union = 100;
+////    }
+//// }
+//// var x = new Foo();
+//// x/**/
+
+
+goTo.marker();
+edit.insert('.');
+verify.completionListContains("bar", /*displayText*/ undefined, /*documentation*/ undefined, "property");
+verify.completionListContains("thing", /*displayText*/ undefined, /*documentation*/ undefined, "property");
+verify.completionListContains("union", /*displayText*/ undefined, /*documentation*/ undefined, "property");
+
+edit.insert('bar.');
+verify.completionListContains("substr", /*displayText*/ undefined, /*documentation*/ undefined, "method");
+edit.backspace('bar.'.length);
+
+edit.insert('union.');
+verify.completionListContains("toString", /*displayText*/ undefined, /*documentation*/ undefined, "method");
\ No newline at end of file
diff --git a/tests/cases/fourslash/javaScriptClass2.ts b/tests/cases/fourslash/javaScriptClass2.ts
new file mode 100644
index 0000000000000..d6daa320c5a87
--- /dev/null
+++ b/tests/cases/fourslash/javaScriptClass2.ts
@@ -0,0 +1,22 @@
+///<reference path="fourslash.ts" />
+
+// In an inferred class, we can rename successfully
+
+// @allowNonTsExtensions: true
+// @Filename: Foo.js
+//// class Foo {
+////    constructor() {
+////        this.[|union|] = 'foo';
+////        this./*1*/[|union|] = 100;
+////    }
+////    method() { return this./*2*/[|union|]; }
+//// }
+//// var x = new Foo();
+//// x./*3*/[|union|];
+
+goTo.marker('1');
+verify.renameLocations(/*findInStrings*/false, /*findInComments*/false);
+goTo.marker('2');
+verify.renameLocations(/*findInStrings*/false, /*findInComments*/false);
+goTo.marker('3');
+verify.renameLocations(/*findInStrings*/false, /*findInComments*/false);
diff --git a/tests/cases/fourslash/javaScriptClass3.ts b/tests/cases/fourslash/javaScriptClass3.ts
new file mode 100644
index 0000000000000..47004d53b044f
--- /dev/null
+++ b/tests/cases/fourslash/javaScriptClass3.ts
@@ -0,0 +1,24 @@
+///<reference path="fourslash.ts" />
+
+// In an inferred class, we can to-to-def successfully
+
+// @allowNonTsExtensions: true
+// @Filename: Foo.js
+//// class Foo {
+////    constructor() {
+////        /*dst1*/this.alpha = 10;
+////        /*dst2*/this.beta = 'gamma';
+////    }
+////    method() { return this.alpha; }
+//// }
+//// var x = new Foo();
+//// x.alpha/*src1*/;
+//// x.beta/*src2*/;
+
+goTo.marker('src1');
+goTo.definition();
+verify.caretAtMarker('dst1');
+
+goTo.marker('src2');
+goTo.definition();
+verify.caretAtMarker('dst2');
diff --git a/tests/cases/fourslash/javaScriptClass4.ts b/tests/cases/fourslash/javaScriptClass4.ts
new file mode 100644
index 0000000000000..1148d5f320eb2
--- /dev/null
+++ b/tests/cases/fourslash/javaScriptClass4.ts
@@ -0,0 +1,22 @@
+///<reference path="fourslash.ts" />
+
+// Classes have their shape inferred from assignments
+// to properties of 'this' in the constructor
+
+// @allowNonTsExtensions: true
+// @Filename: Foo.js
+//// class Foo {
+////    constructor() {
+////        /**
+////          * @type {string}
+////        */
+////        this.baz = null;
+////    }
+//// }
+//// var x = new Foo();
+//// x/**/
+
+goTo.marker();
+edit.insert('.baz.');
+verify.completionListContains("substr", /*displayText*/ undefined, /*documentation*/ undefined, "method");
+
diff --git a/tests/cases/fourslash/jsdocNullableUnion.ts b/tests/cases/fourslash/jsdocNullableUnion.ts
new file mode 100644
index 0000000000000..19dc9818d6950
--- /dev/null
+++ b/tests/cases/fourslash/jsdocNullableUnion.ts
@@ -0,0 +1,23 @@
+///<reference path="fourslash.ts" />
+// @allowNonTsExtensions: true
+// @Filename: Foo.js
+////
+//// * @param {never | {x: string}} p1
+//// * @param {undefined | {y: number}} p2
+//// * @param {null | {z: boolean}} p3
+//// * @returns {void} nothing
+//// */
+////function f(p1, p2, p3) {
+////    p1./*1*/
+////    p2./*2*/
+////    p3./*3*/
+////}
+
+goTo.marker('1');
+verify.memberListContains("x");
+
+goTo.marker('2');
+verify.memberListContains("y");
+
+goTo.marker('3');
+verify.memberListContains("z");
diff --git a/tests/cases/fourslash/localGetReferences.ts b/tests/cases/fourslash/localGetReferences.ts
index ada4947acde52..b05346a366a4a 100644
--- a/tests/cases/fourslash/localGetReferences.ts
+++ b/tests/cases/fourslash/localGetReferences.ts
@@ -205,12 +205,13 @@ const rangesByText = test.rangesByText();
 for (const text in rangesByText) {
     const ranges = rangesByText[text];
     if (text === "globalVar") {
-        function isShadow(r) {
-            return r.marker && r.marker.data && r.marker.data.shadow;
-        }
         verify.rangesReferenceEachOther(ranges.filter(isShadow));
         verify.rangesReferenceEachOther(ranges.filter(r => !isShadow(r)));
     } else {
         verify.rangesReferenceEachOther(ranges);
     }
 }
+
+function isShadow(r) {
+    return r.marker && r.marker.data && r.marker.data.shadow;
+}
diff --git a/tests/cases/fourslash/server/completionEntryDetailAcrossFiles01.ts b/tests/cases/fourslash/server/completionEntryDetailAcrossFiles01.ts
new file mode 100644
index 0000000000000..243975fde2d45
--- /dev/null
+++ b/tests/cases/fourslash/server/completionEntryDetailAcrossFiles01.ts
@@ -0,0 +1,20 @@
+/// <reference path="../fourslash.ts"/>
+
+// @allowNonTsExtensions: true
+// @Filename: a.js
+//// /**
+////  * Modify the parameter
+////  * @param {string} p1
+////  */
+//// var foo = function (p1) { }
+//// exports.foo = foo;
+//// fo/*1*/
+
+// @Filename: b.ts
+//// import a = require("./a");
+//// a.fo/*2*/
+
+goTo.marker('1');
+verify.completionEntryDetailIs("foo", "var foo: (p1: string) => void", "Modify the parameter");
+goTo.marker('2');
+verify.completionEntryDetailIs("foo", "(property) a.foo: (p1: string) => void", "Modify the parameter");
diff --git a/tests/cases/fourslash/server/completionEntryDetailAcrossFiles02.ts b/tests/cases/fourslash/server/completionEntryDetailAcrossFiles02.ts
new file mode 100644
index 0000000000000..2c5e53ea224cc
--- /dev/null
+++ b/tests/cases/fourslash/server/completionEntryDetailAcrossFiles02.ts
@@ -0,0 +1,20 @@
+/// <reference path="../fourslash.ts"/>
+
+// @allowNonTsExtensions: true
+// @Filename: a.js
+//// /**
+////  * Modify the parameter
+////  * @param {string} p1
+////  */
+//// var foo = function (p1) { }
+//// module.exports.foo = foo;
+//// fo/*1*/
+
+// @Filename: b.ts
+//// import a = require("./a");
+//// a.fo/*2*/
+
+goTo.marker('1');
+verify.completionEntryDetailIs("foo", "var foo: (p1: string) => void", "Modify the parameter");
+goTo.marker('2');
+verify.completionEntryDetailIs("foo", "(property) a.foo: (p1: string) => void", "Modify the parameter");
diff --git a/tests/cases/fourslash/syntacticClassificationsDocComment4.ts b/tests/cases/fourslash/syntacticClassificationsDocComment4.ts
new file mode 100644
index 0000000000000..d8ac2f12d8b32
--- /dev/null
+++ b/tests/cases/fourslash/syntacticClassificationsDocComment4.ts
@@ -0,0 +1,24 @@
+/// <reference path="fourslash.ts"/>
+
+//// /** @param {number} p1 */
+//// function foo(p1) {}
+
+var c = classification;
+verify.syntacticClassificationsAre(
+    c.comment("/** "),
+    c.punctuation("@"),
+    c.docCommentTagName("param"),
+    c.comment(" "),
+    c.punctuation("{"),
+    c.keyword("number"),
+    c.punctuation("}"),
+    c.comment(" "),
+    c.parameterName("p1"),
+    c.comment(" */"),
+    c.keyword("function"),
+    c.identifier("foo"),
+    c.punctuation("("),
+    c.parameterName("p1"),
+    c.punctuation(")"),
+    c.punctuation("{"),
+    c.punctuation("}"));
diff --git a/tests/webTestServer.ts b/tests/webTestServer.ts
index f7b1437d9ff11..97027dfdd4913 100644
--- a/tests/webTestServer.ts
+++ b/tests/webTestServer.ts
@@ -152,19 +152,21 @@ function handleResolutionRequest(filePath: string, res: http.ServerResponse) {
     let resolvedPath = path.resolve(filePath, "");
     resolvedPath = resolvedPath.substring(resolvedPath.indexOf("tests"));
     resolvedPath = switchToForwardSlashes(resolvedPath);
-    send("success", res, resolvedPath, "text/javascript");
-    return;
+    send(ResponseCode.Success, res, resolvedPath);
 }
 
-function send(result: "fail", res: http.ServerResponse, contents: string, contentType?: string): void;
-function send(result: "success", res: http.ServerResponse, contents: string, contentType?: string): void;
-function send(result: "unknown", res: http.ServerResponse, contents: string, contentType?: string): void;
-function send(result: string, res: http.ServerResponse, contents: string, contentType?: string): void
-function send(result: string, res: http.ServerResponse, contents: string, contentType = "binary"): void {
-    const responseCode = result === "success" ? 200 : result === "fail" ? 500 : result === "unknown" ? 404 : parseInt(result);
+const enum ResponseCode {
+    Success = 200,
+    BadRequest = 400,
+    NotFound = 404,
+    MethodNotAllowed = 405,
+    PayloadTooLarge = 413,
+    Fail = 500
+}
+
+function send(responseCode: number, res: http.ServerResponse, contents: string, contentType = "binary"): void {
     res.writeHead(responseCode, { "Content-Type": contentType });
     res.end(contents);
-    return;
 }
 
 // Reads the data from a post request and passes it to the given callback
@@ -177,7 +179,7 @@ function processPost(req: http.ServerRequest, res: http.ServerResponse, callback
             queryData += data;
             if (queryData.length > 1e8) {
                 queryData = "";
-                send("413", res, undefined);
+                send(ResponseCode.PayloadTooLarge, res, undefined);
                 console.log("ERROR: destroying connection");
                 req.connection.destroy();
             }
@@ -190,7 +192,7 @@ function processPost(req: http.ServerRequest, res: http.ServerResponse, callback
 
     }
     else {
-        send("405", res, undefined);
+        send(ResponseCode.MethodNotAllowed, res, undefined);
     }
 }
 
@@ -237,16 +239,16 @@ function handleRequestOperation(req: http.ServerRequest, res: http.ServerRespons
     switch (operation) {
         case RequestType.GetDir:
             const filesInFolder = dir(reqPath, "", { recursive: true });
-            send("success", res, filesInFolder.join(","));
+            send(ResponseCode.Success, res, filesInFolder.join(","));
             break;
         case RequestType.GetFile:
             fs.readFile(reqPath, (err, file) => {
                 const contentType = contentTypeForExtension(path.extname(reqPath));
                 if (err) {
-                    send("fail", res, err.message, contentType);
+                    send(ResponseCode.NotFound, res, err.message, contentType);
                 }
                 else {
-                    send("success", res, <any>file, contentType);
+                    send(ResponseCode.Success, res, <any>file, contentType);
                 }
             });
             break;
@@ -258,33 +260,33 @@ function handleRequestOperation(req: http.ServerRequest, res: http.ServerRespons
             processPost(req, res, (data) => {
                 writeFile(reqPath, data, { recursive: true });
             });
-            send("success", res, undefined);
+            send(ResponseCode.Success, res, undefined);
             break;
         case RequestType.WriteDir:
-            ensureDirectoriesExist(reqPath);
-            send("success", res, undefined);
+            fs.mkdirSync(reqPath);
+            send(ResponseCode.Success, res, undefined);
             break;
         case RequestType.DeleteFile:
             if (fs.existsSync(reqPath)) {
                 fs.unlinkSync(reqPath);
             }
-            send("success", res, undefined);
+            send(ResponseCode.Success, res, undefined);
             break;
         case RequestType.DeleteDir:
             if (fs.existsSync(reqPath)) {
                 fs.rmdirSync(reqPath);
             }
-            send("success", res, undefined);
+            send(ResponseCode.Success, res, undefined);
             break;
         case RequestType.AppendFile:
             processPost(req, res, (data) => {
                 fs.appendFileSync(reqPath, data);
             });
-            send("success", res, undefined);
+            send(ResponseCode.Success, res, undefined);
             break;
         case RequestType.Unknown:
         default:
-            send("unknown", res, undefined);
+            send(ResponseCode.BadRequest, res, undefined);
             break;
     }
 
diff --git a/tslint.json b/tslint.json
index a46e58f8c296c..f058eab3dd658 100644
--- a/tslint.json
+++ b/tslint.json
@@ -32,7 +32,7 @@
             "property-declaration": "nospace",
             "variable-declaration": "nospace"
         }],
-        "next-line": [true, 
+        "next-line": [true,
             "check-catch",
             "check-else"
         ],
@@ -44,7 +44,6 @@
         "boolean-trivia": true,
         "type-operator-spacing": true,
         "prefer-const": true,
-        "no-in-operator": true,
         "no-increment-decrement": true,
         "object-literal-surrounding-space": true,
         "no-type-assertion-whitespace": true