Merge branch 'master' into dynamicNames

.gitignore

@@ -58,5 +58,4 @@ internal/
 !tests/baselines/reference/project/nodeModules*/**/*
 .idea
 yarn.lock
-package-lock.json
 .parallelperf.*

.mailmap

@@ -276,4 +276,15 @@ Francois Wouts  <f@codonut.com>
 Jan Melcher  <jan.melcher@aeb.com> Jan Melcher  <mail@jan-melcher.de>
 Matt Mitchell  <mmitche@microsoft.com>
 Maxwell Paul Brickner  <mbrickn@users.noreply.github.com>
-Tycho Grouwstra  <tychogrouwstra@gmail.com>
+Tycho Grouwstra  <tychogrouwstra@gmail.com>
+Adrian Leonhard  <adrianleonhard@gmail.com>
+Alex Chugaev  <achugaev93@gmail.com>
+Henry Mercer  <henry.mercer@me.com>
+Ivan Enderlin  <ivan.enderlin@hoa-project.net>
+Joe Calzaretta  <jcalz@mit.edu>
+Magnus Kulke  <mkulke@gmail.com>
+Stas Vilchik  <stas.vilchik@sonarsource.com>
+Taras Mankovski  <tarasm@gmail.com>
+Thomas den Hollander  <ThomasdenH@users.noreply.github.com>
+Vakhurin Sergey  <igelbox@gmail.com>
+Zeeshan Ahmed  <ziishaned@gmail.com>

.travis.yml

@@ -17,6 +17,7 @@ branches:
   only:
   - master
   - release-2.5
+  - release-2.6
 
 install:
   - npm uninstall typescript --no-save

AUTHORS.md

@@ -3,8 +3,10 @@ TypeScript is authored by:
 * Abubaker Bashir
 * Adam Freidin
 * Adi Dahiya
+* Adrian Leonhard 
 * Ahmad Farid
 * Akshar Patel
+* Alex Chugaev 
 * Alex Eagle
 * Alexander Kuvaev
 * Alexander Rusakov 
@@ -105,6 +107,7 @@ TypeScript is authored by:
 * Halasi Tamás 
 * Harald Niesche
 * Hendrik Liebau 
+* Henry Mercer 
 * Herrington Darkholme
 * Homa Wong 
 * Iain Monro
@@ -112,6 +115,7 @@ TypeScript is authored by:
 * Ika 
 * Ingvar Stepanyan
 * Isiah Meadows
+* Ivan Enderlin 
 * Ivo Gabe de Wolff
 * Iwata Hidetaka 
 * Jakub Młokosiewicz 
@@ -127,6 +131,7 @@ TypeScript is authored by:
 * Jeffrey Morlan
 * Jesse Schalken
 * Jiri Tobisek
+* Joe Calzaretta 
 * Joe Chung 
 * Joel Day 
 * Joey Wilson
@@ -161,6 +166,7 @@ TypeScript is authored by:
 * Lucien Greathouse
 * Lukas Elmer 
 * Magnus Hiie 
+* Magnus Kulke 
 * Manish Giri
 * Marin Marinov
 * Marius Schulz 
@@ -232,13 +238,16 @@ TypeScript is authored by:
 * Soo Jae Hwang 
 * Stan Thomas
 * Stanislav Sysoev
+* Stas Vilchik 
 * Steve Lucco
 * Sudheesh Singanamalla 
 * Sébastien Arod
 * @T18970237136
 * @t_
+* Taras Mankovski 
 * Tarik Ozket
 * Tetsuharu Ohzeki
+* Thomas den Hollander 
 * Thomas Loubiou
 * Tien Hoanhtien
 * Tim Lancina 
@@ -253,6 +262,7 @@ TypeScript is authored by:
 * TruongSinh Tran-Nguyen
 * Tycho Grouwstra 
 * Vadi Taslim 
+* Vakhurin Sergey 
 * Vidar Tonaas Fauske
 * Viktor Zozulyak
 * Vilic Vane
@@ -263,5 +273,6 @@ TypeScript is authored by:
 * York Yao
 * @yortus
 * Yuichi Nukiyama
+* Zeeshan Ahmed 
 * Zev Spitz
 * Zhengbo Li

Gulpfile.ts

@@ -64,7 +64,7 @@ const cmdLineOptions = minimist(process.argv.slice(2), {
         browser: process.env.browser || process.env.b || "IE",
         timeout: process.env.timeout || 40000,
         tests: process.env.test || process.env.tests || process.env.t,
-        light: process.env.light || false,
+        light: process.env.light === undefined || process.env.light !== "false",
         reporter: process.env.reporter || process.env.r,
         lint: process.env.lint || true,
         files: process.env.f || process.env.file || process.env.files || "",
@@ -87,7 +87,7 @@ function possiblyQuote(cmd: string) {
 }
 
 let useDebugMode = true;
-let host = cmdLineOptions["host"];
+let host = cmdLineOptions.host;
 
 // Constants
 const compilerDirectory = "src/compiler/";
@@ -180,6 +180,23 @@ const libraryTargets = librarySourceMap.map(function(f) {
     return path.join(builtLocalDirectory, f.target);
 });
 
+/**
+ * .lcg file is what localization team uses to know what messages to localize.
+ * The file is always generated in 'enu\diagnosticMessages.generated.json.lcg'
+ */
+const generatedLCGFile = path.join(builtLocalDirectory, "enu", "diagnosticMessages.generated.json.lcg");
+
+/**
+ * The localization target produces the two following transformations:
+ *    1. 'src\loc\lcl\<locale>\diagnosticMessages.generated.json.lcl' => 'built\local\<locale>\diagnosticMessages.generated.json'
+ *       convert localized resources into a .json file the compiler can understand
+ *    2. 'src\compiler\diagnosticMessages.generated.json' => 'built\local\ENU\diagnosticMessages.generated.json.lcg'
+ *       generate the lcg file (source of messages to localize) from the diagnosticMessages.generated.json
+ */
+const localizationTargets = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-BR", "ru", "tr", "zh-CN", "zh-TW"].map(function (f) {
+    return path.join(builtLocalDirectory, f, "diagnosticMessages.generated.json");
+}).concat(generatedLCGFile);
+
 for (const i in libraryTargets) {
     const entry = librarySourceMap[i];
     const target = libraryTargets[i];
@@ -398,7 +415,6 @@ gulp.task(generateLocalizedDiagnosticMessagesJs, /*help*/ false, [], () => {
 });
 
 // Localize diagnostics
-const generatedLCGFile = path.join(builtLocalDirectory, "enu", "diagnosticMessages.generated.json.lcg");
 gulp.task(generatedLCGFile, [generateLocalizedDiagnosticMessagesJs, diagnosticInfoMapTs], (done) => {
     if (fs.existsSync(builtLocalDirectory) && needsUpdate(generatedDiagnosticMessagesJSON, generatedLCGFile)) {
         exec(host, [generateLocalizedDiagnosticMessagesJs, lclDirectory, builtLocalDirectory, generatedDiagnosticMessagesJSON], done, done);
@@ -576,8 +592,7 @@ gulp.task("dontUseDebugMode", /*help*/ false, [], (done) => { useDebugMode = fal
 gulp.task("VerifyLKG", /*help*/ false, [], () => {
     const expectedFiles = [builtLocalCompiler, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile, typingsInstallerJs, cancellationTokenJs].concat(libraryTargets);
     const missingFiles = expectedFiles.
-        concat(fs.readdirSync(lclDirectory).map(function (d) { return path.join(builtLocalDirectory, d, "diagnosticMessages.generated.json"); })).
-        concat(generatedLCGFile).
+        concat(localizationTargets).
         filter(f => !fs.existsSync(f));
     if (missingFiles.length > 0) {
         throw new Error("Cannot replace the LKG unless all built targets are present in directory " + builtLocalDirectory +
@@ -636,15 +651,15 @@ function restoreSavedNodeEnv() {
 }
 
 function runConsoleTests(defaultReporter: string, runInParallel: boolean, done: (e?: any) => void) {
-    const lintFlag = cmdLineOptions["lint"];
+    const lintFlag = cmdLineOptions.lint;
     cleanTestDirs((err) => {
         if (err) { console.error(err); failWithStatus(err, 1); }
-        let testTimeout = cmdLineOptions["timeout"];
-        const debug = cmdLineOptions["debug"];
-        const inspect = cmdLineOptions["inspect"];
-        const tests = cmdLineOptions["tests"];
-        const light = cmdLineOptions["light"];
-        const stackTraceLimit = cmdLineOptions["stackTraceLimit"];
+        let testTimeout = cmdLineOptions.timeout;
+        const debug = cmdLineOptions.debug;
+        const inspect = cmdLineOptions.inspect;
+        const tests = cmdLineOptions.tests;
+        const light = cmdLineOptions.light;
+        const stackTraceLimit = cmdLineOptions.stackTraceLimit;
         const testConfigFile = "test.config";
         if (fs.existsSync(testConfigFile)) {
             fs.unlinkSync(testConfigFile);
@@ -660,7 +675,7 @@ function runConsoleTests(defaultReporter: string, runInParallel: boolean, done:
             } while (fs.existsSync(taskConfigsFolder));
             fs.mkdirSync(taskConfigsFolder);
 
-            workerCount = cmdLineOptions["workers"];
+            workerCount = cmdLineOptions.workers;
         }
 
         if (tests || light || taskConfigsFolder) {
@@ -671,8 +686,8 @@ function runConsoleTests(defaultReporter: string, runInParallel: boolean, done:
             testTimeout = 400000;
         }
 
-        const colors = cmdLineOptions["colors"];
-        const reporter = cmdLineOptions["reporter"] || defaultReporter;
+        const colors = cmdLineOptions.colors;
+        const reporter = cmdLineOptions.reporter || defaultReporter;
 
         // 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
@@ -860,7 +875,7 @@ function cleanTestDirs(done: (e?: any) => void) {
 
 // used to pass data from jake command line directly to run.js
 function writeTestConfigFile(tests: string, light: boolean, taskConfigsFolder?: string, workerCount?: number, stackTraceLimit?: string) {
-    const testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light, workerCount, stackTraceLimit, taskConfigsFolder, noColor: !cmdLineOptions["colors"] });
+    const testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light, workerCount, stackTraceLimit, taskConfigsFolder, noColor: !cmdLineOptions.colors });
     console.log("Running tests with config: " + testConfigContents);
     fs.writeFileSync("test.config", testConfigContents);
 }
@@ -870,8 +885,8 @@ gulp.task("runtests-browser", "Runs the tests using the built run.js file like '
     cleanTestDirs((err) => {
         if (err) { console.error(err); done(err); process.exit(1); }
         host = "node";
-        const tests = cmdLineOptions["tests"];
-        const light = cmdLineOptions["light"];
+        const tests = cmdLineOptions.tests;
+        const light = cmdLineOptions.light;
         const testConfigFile = "test.config";
         if (fs.existsSync(testConfigFile)) {
             fs.unlinkSync(testConfigFile);
@@ -881,8 +896,8 @@ gulp.task("runtests-browser", "Runs the tests using the built run.js file like '
         }
 
         const args = [nodeServerOutFile];
-        if (cmdLineOptions["browser"]) {
-            args.push(cmdLineOptions["browser"]);
+        if (cmdLineOptions.browser) {
+            args.push(cmdLineOptions.browser);
         }
         if (tests) {
             args.push(JSON.stringify(tests));
@@ -892,13 +907,13 @@ gulp.task("runtests-browser", "Runs the tests using the built run.js file like '
 });
 
 gulp.task("generate-code-coverage", "Generates code coverage data via istanbul", ["tests"], (done) => {
-    const testTimeout = cmdLineOptions["timeout"];
+    const testTimeout = cmdLineOptions.timeout;
     exec("istanbul", ["cover", "node_modules/mocha/bin/_mocha", "--", "-R", "min", "-t", testTimeout.toString(), run], done, done);
 });
 
 
 function getDiffTool() {
-    const program = process.env["DIFF"];
+    const program = process.env.DIFF;
     if (!program) {
         console.error("Add the 'DIFF' environment variable to the path of the program you want to use.");
         process.exit(1);
@@ -1019,7 +1034,7 @@ gulp.task(instrumenterJsPath, /*help*/ false, [servicesFile], () => {
 });
 
 gulp.task("tsc-instrumented", "Builds an instrumented tsc.js - run with --test=[testname]", ["local", loggedIOJsPath, instrumenterJsPath, servicesFile], (done) => {
-    const test = cmdLineOptions["tests"] || "iocapture";
+    const test = cmdLineOptions.tests || "iocapture";
     exec(host, [instrumenterJsPath, "record", test, builtLocalCompiler], done, done);
 });
 
@@ -1088,7 +1103,7 @@ function spawnLintWorker(files: {path: string}[], callback: (failures: number) =
 
 gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are: --f[iles]=regex", ["build-rules"], () => {
     if (fold.isTravis()) console.log(fold.start("lint"));
-    const fileMatcher = cmdLineOptions["files"];
+    const fileMatcher = cmdLineOptions.files;
     const files = fileMatcher
         ? `src/**/${fileMatcher}`
         : "Gulpfile.ts 'scripts/generateLocalizedDiagnosticMessages.ts' 'scripts/tslint/**/*.ts' 'src/**/*.ts' --exclude src/lib/es5.d.ts --exclude 'src/lib/*.generated.d.ts'";

Jakefile.js

@@ -154,6 +154,7 @@ var harnessSources = harnessCoreSources.concat([
     "symbolWalker.ts",
     "languageService.ts",
     "publicApi.ts",
+    "hostNewLineSupport.ts",
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
@@ -238,6 +239,23 @@ var libraryTargets = librarySourceMap.map(function (f) {
     return path.join(builtLocalDirectory, f.target);
 });
 
+/**
+ * .lcg file is what localization team uses to know what messages to localize.
+ * The file is always generated in 'enu\diagnosticMessages.generated.json.lcg'
+ */
+var generatedLCGFile = path.join(builtLocalDirectory, "enu", "diagnosticMessages.generated.json.lcg");
+
+/**
+ * The localization target produces the two following transformations:
+ *    1. 'src\loc\lcl\<locale>\diagnosticMessages.generated.json.lcl' => 'built\local\<locale>\diagnosticMessages.generated.json'
+ *       convert localized resources into a .json file the compiler can understand
+ *    2. 'src\compiler\diagnosticMessages.generated.json' => 'built\local\ENU\diagnosticMessages.generated.json.lcg'
+ *       generate the lcg file (source of messages to localize) from the diagnosticMessages.generated.json
+ */
+var localizationTargets = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-BR", "ru", "tr", "zh-CN", "zh-TW"].map(function (f) {
+    return path.join(builtLocalDirectory, f);
+}).concat(path.dirname(generatedLCGFile));
+
 // Prepends the contents of prefixFile to destinationFile
 function prependFile(prefixFile, destinationFile) {
     if (!fs.existsSync(prefixFile)) {
@@ -443,7 +461,6 @@ compileFile(generateLocalizedDiagnosticMessagesJs,
     /*useBuiltCompiler*/ false, { noOutFile: true, types: ["node", "xml2js"] });
 
 // Localize diagnostics
-var generatedLCGFile = path.join(builtLocalDirectory, "enu", "diagnosticMessages.generated.json.lcg");
 file(generatedLCGFile, [generateLocalizedDiagnosticMessagesJs, diagnosticInfoMapTs, generatedDiagnosticMessagesJSON], function () {
     var cmd = host + " " + generateLocalizedDiagnosticMessagesJs + " " + lclDirectory + " " + builtLocalDirectory + " " + generatedDiagnosticMessagesJSON;
     console.log(cmd);
@@ -735,8 +752,7 @@ desc("Makes a new LKG out of the built js files");
 task("LKG", ["clean", "release", "local"].concat(libraryTargets), function () {
     var expectedFiles = [tscFile, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile, cancellationTokenFile, typingsInstallerFile, buildProtocolDts, watchGuardFile].
         concat(libraryTargets).
-        concat(fs.readdirSync(lclDirectory).map(function (d) { return path.join(builtLocalDirectory, d) })).
-        concat(path.dirname(generatedLCGFile));
+        concat(localizationTargets);
     var missingFiles = expectedFiles.filter(function (f) {
         return !fs.existsSync(f);
     });
@@ -855,7 +871,7 @@ function runConsoleTests(defaultReporter, runInParallel) {
     var inspect = process.env.inspect || process.env["inspect-brk"] || process.env.i;
     var testTimeout = process.env.timeout || defaultTestTimeout;
     var tests = process.env.test || process.env.tests || process.env.t;
-    var light = process.env.light || false;
+    var light = process.env.light === undefined || process.env.light !== "false";
     var stackTraceLimit = process.env.stackTraceLimit;
     var testConfigFile = 'test.config';
     if (fs.existsSync(testConfigFile)) {

issue_template.md

@@ -2,7 +2,8 @@
 <!-- QUESTIONS: This is not a general support forum! Ask Qs at http://stackoverflow.com/questions/tagged/typescript -->
 <!-- SUGGESTIONS: See https://github.com/Microsoft/TypeScript-wiki/blob/master/Writing-Good-Design-Proposals.md -->
 
-**TypeScript Version:**  2.4.0 / nightly (2.5.0-dev.201xxxxx)
+<!-- Please try to reproduce the issue with `typescript@next`. It may have already been fixed. -->
+**TypeScript Version:**  2.6.0-dev.201xxxxx
 
 **Code**
 

package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "http://typescriptlang.org/",
-    "version": "2.6.0",
+    "version": "2.7.0",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -83,7 +83,7 @@
     },
     "scripts": {
         "pretest": "jake tests",
-        "test": "jake runtests-parallel",
+        "test": "jake runtests-parallel light=false",
         "build": "npm run build:compiler && npm run build:tests",
         "build:compiler": "jake local",
         "build:tests": "jake tests",

pull_request_template.md

@@ -3,7 +3,7 @@ Thank you for submitting a pull request!
 
 Here's a checklist you might find useful.
 [ ] There is an associated issue that is labelled
-  'Bug' or 'Accepting PRs' or is in the Community milestone
+  'Bug' or 'help wanted' or is in the Community milestone
 [ ] Code is up-to-date with the `master` branch
 [ ] You've successfully run `jake runtests` locally
 [ ] You've signed the CLA

scripts/buildProtocol.ts

@@ -51,22 +51,25 @@ class DeclarationsWalker {
             return this.processType((<any>type).typeArguments[0]);
         }
         else {
-            for (const decl of s.getDeclarations()) {
-                const sourceFile = decl.getSourceFile();
-                if (sourceFile === this.protocolFile || path.basename(sourceFile.fileName) === "lib.d.ts") {
-                    return;
-                }
-                if (decl.kind === ts.SyntaxKind.EnumDeclaration && !isStringEnum(decl as ts.EnumDeclaration)) {
-                    this.removedTypes.push(type);
-                    return;
-                }
-                else {
-                    // splice declaration in final d.ts file
-                    let text = decl.getFullText();
-                    this.text += `${text}\n`;
-                    // recursively pull all dependencies into result dts file
+            const declarations = s.getDeclarations();
+            if (declarations) {
+                for (const decl of declarations) {
+                    const sourceFile = decl.getSourceFile();
+                    if (sourceFile === this.protocolFile || path.basename(sourceFile.fileName) === "lib.d.ts") {
+                        return;
+                    }
+                    if (decl.kind === ts.SyntaxKind.EnumDeclaration && !isStringEnum(decl as ts.EnumDeclaration)) {
+                        this.removedTypes.push(type);
+                        return;
+                    }
+                    else {
+                        // splice declaration in final d.ts file
+                        let text = decl.getFullText();
+                        this.text += `${text}\n`;
+                        // recursively pull all dependencies into result dts file
 
-                    this.visitTypeNodes(decl);
+                        this.visitTypeNodes(decl);
+                    }
                 }
             }
         }

scripts/generateLocalizedDiagnosticMessages.ts

@@ -27,16 +27,54 @@ function main(): void {
 
     function visitDirectory(name: string) {
         const inputFilePath = path.join(inputPath, name, "diagnosticMessages", "diagnosticMessages.generated.json.lcl");
-        const outputFilePath = path.join(outputPath, name, "diagnosticMessages.generated.json");
+
         fs.readFile(inputFilePath, (err, data) => {
             handleError(err);
             xml2js.parseString(data.toString(), (err, result) => {
                 handleError(err);
-                writeFile(outputFilePath, xmlObjectToString(result));
+                if (!result || !result.LCX || !result.LCX.$ || !result.LCX.$.TgtCul) {
+                    console.error("Unexpected XML file structure. Expected to find result.LCX.$.TgtCul.");
+                    process.exit(1);
+                }
+                const outputDirectoryName = getPreferedLocaleName(result.LCX.$.TgtCul);
+                if (!outputDirectoryName) {
+                    console.error(`Invalid output locale name for '${result.LCX.$.TgtCul}'.`);
+                    process.exit(1);
+                }
+                writeFile(path.join(outputPath, outputDirectoryName, "diagnosticMessages.generated.json"), xmlObjectToString(result));
             });
         });
     }
 
+    /**
+     * A locale name is based on the language tagging conventions of RFC 4646 (Windows Vista
+     * and later), and is represented by LOCALE_SNAME.
+     * Generally, the pattern <language>-<REGION> is used. Here, language is a lowercase ISO 639
+     * language code. The codes from ISO 639-1 are used when available. Otherwise, codes from
+     * ISO 639-2/T are used. REGION specifies an uppercase ISO 3166-1 country/region identifier.
+     * For example, the locale name for English (United States) is "en-US" and the locale name
+     * for Divehi (Maldives) is "dv-MV".
+     *
+     * If the locale is a neutral locale (no region), the LOCALE_SNAME value follows the
+     * pattern <language>. If it is a neutral locale for which the script is significant, the
+     * pattern is <language>-<Script>.
+     *
+     * More at https://msdn.microsoft.com/en-us/library/windows/desktop/dd373814(v=vs.85).aspx
+     *
+     * Most of the languages we support are neutral locales, so we want to use the language name.
+     * There are three exceptions, zh-CN, zh-TW and pt-BR.
+     */
+    function getPreferedLocaleName(localeName: string) {
+        switch (localeName) {
+            case "zh-CN":
+            case "zh-TW":
+            case "pt-BR":
+                return localeName;
+            default:
+                return localeName.split("-")[0];
+        }
+    }
+
     function handleError(err: null | object) {
         if (err) {
             console.error(err);
@@ -46,9 +84,9 @@ function main(): void {
 
     function xmlObjectToString(o: any) {
         const out: any = {};
-        for (const item of o["LCX"]["Item"][0]["Item"][0]["Item"]) {
-            let ItemId = item["$"]["ItemId"];
-            let Val = item["Str"][0]["Tgt"] ? item["Str"][0]["Tgt"][0]["Val"][0] : item["Str"][0]["Val"][0];
+        for (const item of o.LCX.Item[0].Item[0].Item) {
+            let ItemId = item.$.ItemId;
+            let Val = item.Str[0].Tgt ? item.Str[0].Tgt[0].Val[0] : item.Str[0].Val[0];
 
             if (typeof ItemId !== "string" || typeof Val !== "string") {
                 console.error("Unexpected XML file structure");

src/compiler/binder.ts

@@ -143,6 +143,15 @@ namespace ts {
         let subtreeTransformFlags: TransformFlags = TransformFlags.None;
         let skipTransformFlagAggregation: boolean;
 
+        /**
+         * Inside the binder, we may create a diagnostic for an as-yet unbound node (with potentially no parent pointers, implying no accessible source file)
+         * If so, the node _must_ be in the current file (as that's the only way anything could have traversed to it to yield it as the error node)
+         * This version of `createDiagnosticForNode` uses the binder's context to account for this, and always yields correct diagnostics even in these situations.
+         */
+        function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): Diagnostic {
+            return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
+        }
+
         function bindSourceFile(f: SourceFile, opts: CompilerOptions) {
             file = f;
             options = opts;
@@ -230,6 +239,10 @@ namespace ts {
         // Should not be called on a declaration with a computed property name,
         // unless it is a well known Symbol.
         function getDeclarationName(node: Declaration): __String {
+            if (node.kind === SyntaxKind.ExportAssignment) {
+                return (<ExportAssignment>node).isExportEquals ? InternalSymbolName.ExportEquals : InternalSymbolName.Default;
+            }
+
             const name = getNameOfDeclaration(node);
             if (name) {
                 if (isAmbientModule(node)) {
@@ -261,8 +274,6 @@ namespace ts {
                     return InternalSymbolName.Index;
                 case SyntaxKind.ExportDeclaration:
                     return InternalSymbolName.ExportStar;
-                case SyntaxKind.ExportAssignment:
-                    return (<ExportAssignment>node).isExportEquals ? InternalSymbolName.ExportEquals : InternalSymbolName.Default;
                 case SyntaxKind.BinaryExpression:
                     if (getSpecialPropertyAssignmentKind(node as BinaryExpression) === SpecialPropertyAssignmentKind.ModuleExports) {
                         // module.exports = ...
@@ -2144,7 +2155,7 @@ namespace ts {
                     // falls through
                 case SyntaxKind.JSDocPropertyTag:
                     const propTag = node as JSDocPropertyLikeTag;
-                    const flags = propTag.isBracketed || propTag.typeExpression.type.kind === SyntaxKind.JSDocOptionalType ?
+                    const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === SyntaxKind.JSDocOptionalType ?
                         SymbolFlags.Property | SymbolFlags.Optional :
                         SymbolFlags.Property;
                     return declareSymbolAndAddToSymbolTable(propTag, flags, SymbolFlags.PropertyExcludes);
@@ -2269,16 +2280,13 @@ namespace ts {
         function isExportsOrModuleExportsOrAlias(node: Node): boolean {
             return isExportsIdentifier(node) ||
                 isModuleExportsPropertyAccessExpression(node) ||
-                isNameOfExportsOrModuleExportsAliasDeclaration(node);
+                isIdentifier(node) && isNameOfExportsOrModuleExportsAliasDeclaration(node);
         }
 
-        function isNameOfExportsOrModuleExportsAliasDeclaration(node: Node) {
-            if (isIdentifier(node)) {
-                const symbol = lookupSymbolForName(node.escapedText);
-                return symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) &&
-                    symbol.valueDeclaration.initializer && isExportsOrModuleExportsOrAliasOrAssignment(symbol.valueDeclaration.initializer);
-            }
-            return false;
+        function isNameOfExportsOrModuleExportsAliasDeclaration(node: Identifier): boolean {
+            const symbol = lookupSymbolForName(node.escapedText);
+            return symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) &&
+                symbol.valueDeclaration.initializer && isExportsOrModuleExportsOrAliasOrAssignment(symbol.valueDeclaration.initializer);
         }
 
         function isExportsOrModuleExportsOrAliasOrAssignment(node: Node): boolean {
@@ -2352,20 +2360,22 @@ namespace ts {
             // Look up the function in the local scope, since prototype assignments should
             // follow the function declaration
             const leftSideOfAssignment = node.left as PropertyAccessExpression;
-            const target = leftSideOfAssignment.expression as Identifier;
+            const target = leftSideOfAssignment.expression;
 
-            // Fix up parent pointers since we're going to use these nodes before we bind into them
-            leftSideOfAssignment.parent = node;
-            target.parent = leftSideOfAssignment;
+            if (isIdentifier(target)) {
+                // Fix up parent pointers since we're going to use these nodes before we bind into them
+                leftSideOfAssignment.parent = node;
+                target.parent = leftSideOfAssignment;
 
-            if (isNameOfExportsOrModuleExportsAliasDeclaration(target)) {
-                // This can be an alias for the 'exports' or 'module.exports' names, e.g.
-                //    var util = module.exports;
-                //    util.property = function ...
-                bindExportsPropertyAssignment(node);
-            }
-            else {
-                bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ false);
+                if (isNameOfExportsOrModuleExportsAliasDeclaration(target)) {
+                    // This can be an alias for the 'exports' or 'module.exports' names, e.g.
+                    //    var util = module.exports;
+                    //    util.property = function ...
+                    bindExportsPropertyAssignment(node);
+                }
+                else {
+                    bindPropertyAssignment(target.escapedText, leftSideOfAssignment, /*isPrototypeProperty*/ false);
+                }
             }
         }
 
@@ -2697,6 +2707,12 @@ namespace ts {
 
         if (expression.kind === SyntaxKind.ImportKeyword) {
             transformFlags |= TransformFlags.ContainsDynamicImport;
+
+            // A dynamic 'import()' call that contains a lexical 'this' will
+            // require a captured 'this' when emitting down-level.
+            if (subtreeFlags & TransformFlags.ContainsLexicalThis) {
+                transformFlags |= TransformFlags.ContainsCapturedLexicalThis;
+            }
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;

src/compiler/builder.ts

@@ -6,58 +6,38 @@ namespace ts {
         emitSkipped: boolean;
     }
 
-    export interface EmitOutputDetailed extends EmitOutput {
-        diagnostics: Diagnostic[];
-        sourceMaps: SourceMapData[];
-        emittedSourceFiles: SourceFile[];
-    }
-
     export interface OutputFile {
         name: string;
         writeByteOrderMark: boolean;
         text: string;
     }
-
-    export function getFileEmitOutput(program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean, isDetailed: boolean,
-        cancellationToken?: CancellationToken, customTransformers?: CustomTransformers): EmitOutput | EmitOutputDetailed {
-        const outputFiles: OutputFile[] = [];
-        let emittedSourceFiles: SourceFile[];
-        const emitResult = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
-        if (!isDetailed) {
-            return { outputFiles, emitSkipped: emitResult.emitSkipped };
-        }
-
-        return {
-            outputFiles,
-            emitSkipped: emitResult.emitSkipped,
-            diagnostics: emitResult.diagnostics,
-            sourceMaps: emitResult.sourceMaps,
-            emittedSourceFiles
-        };
-
-        function writeFile(fileName: string, text: string, writeByteOrderMark: boolean, _onError: (message: string) => void, sourceFiles: SourceFile[]) {
-            outputFiles.push({ name: fileName, writeByteOrderMark, text });
-            if (isDetailed) {
-                emittedSourceFiles = addRange(emittedSourceFiles, sourceFiles);
-            }
-        }
-    }
 }
 
 /* @internal */
 namespace ts {
+    export function getFileEmitOutput(program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean,
+        cancellationToken?: CancellationToken, customTransformers?: CustomTransformers): EmitOutput {
+        const outputFiles: OutputFile[] = [];
+        const emitResult = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
+            return { outputFiles, emitSkipped: emitResult.emitSkipped };
+
+        function writeFile(fileName: string, text: string, writeByteOrderMark: boolean) {
+            outputFiles.push({ name: fileName, writeByteOrderMark, text });
+        }
+    }
+
     export interface Builder {
-        /**
-         * Call this to feed new program
-         */
+        /** Called to inform builder about new program */
         updateProgram(newProgram: Program): void;
-        getFilesAffectedBy(program: Program, path: Path): string[];
-        emitFile(program: Program, path: Path): EmitOutput;
+
+        /** Gets the files affected by the file path */
+        getFilesAffectedBy(program: Program, path: Path): ReadonlyArray<SourceFile>;
 
         /** Emit the changed files and clear the cache of the changed files */
-        emitChangedFiles(program: Program): EmitOutputDetailed[];
+        emitChangedFiles(program: Program, writeFileCallback: WriteFileCallback): ReadonlyArray<EmitResult>;
+
         /** When called gets the semantic diagnostics for the program. It also caches the diagnostics and manage them */
-        getSemanticDiagnostics(program: Program, cancellationToken?: CancellationToken): Diagnostic[];
+        getSemanticDiagnostics(program: Program, cancellationToken?: CancellationToken): ReadonlyArray<Diagnostic>;
 
         /** Called to reset the status of the builder */
         clear(): void;
@@ -73,31 +53,32 @@ namespace ts {
          */
         onRemoveSourceFile(path: Path): void;
         /**
-         * Called when sourceFile is changed
+         * For all source files, either "onUpdateSourceFile" or "onUpdateSourceFileWithSameVersion" will be called.
+         * If the builder is sure that the source file needs an update, "onUpdateSourceFile" will be called;
+         * otherwise "onUpdateSourceFileWithSameVersion" will be called.
          */
         onUpdateSourceFile(program: Program, sourceFile: SourceFile): void;
         /**
-         * Called when source file has not changed but has some of the resolutions invalidated
-         * If returned true, builder will mark the file as changed (noting that something associated with file has changed)
+         * For all source files, either "onUpdateSourceFile" or "onUpdateSourceFileWithSameVersion" will be called.
+         * If the builder is sure that the source file needs an update, "onUpdateSourceFile" will be called;
+         * otherwise "onUpdateSourceFileWithSameVersion" will be called.
+         * This function should return whether the source file should be marked as changed (meaning that something associated with file has changed, e.g. module resolution)
          */
         onUpdateSourceFileWithSameVersion(program: Program, sourceFile: SourceFile): boolean;
         /**
          * Gets the files affected by the script info which has updated shape from the known one
          */
-        getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile, singleFileResult: string[]): string[];
+        getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile): ReadonlyArray<SourceFile>;
     }
 
     interface FileInfo {
-        fileName: string;
         version: string;
         signature: string;
     }
 
     export interface BuilderOptions {
         getCanonicalFileName: (fileName: string) => string;
-        getEmitOutput: (program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean, isDetailed: boolean) => EmitOutput | EmitOutputDetailed;
         computeHash: (data: string) => string;
-        shouldEmitFile: (sourceFile: SourceFile) => boolean;
     }
 
     export function createBuilder(options: BuilderOptions): Builder {
@@ -105,12 +86,13 @@ namespace ts {
         const fileInfos = createMap<FileInfo>();
         const semanticDiagnosticsPerFile = createMap<ReadonlyArray<Diagnostic>>();
         /** The map has key by source file's path that has been changed */
-        const changedFileNames = createMap<string>();
+        const changedFilesSet = createMap<true>();
+        const hasShapeChanged = createMap<true>();
+        let allFilesExcludingDefaultLibraryFile: ReadonlyArray<SourceFile> | undefined;
         let emitHandler: EmitHandler;
         return {
             updateProgram,
             getFilesAffectedBy,
-            emitFile,
             emitChangedFiles,
             getSemanticDiagnostics,
             clear
@@ -124,6 +106,8 @@ namespace ts {
                 fileInfos.clear();
                 semanticDiagnosticsPerFile.clear();
             }
+            hasShapeChanged.clear();
+            allFilesExcludingDefaultLibraryFile = undefined;
             mutateMap(
                 fileInfos,
                 arrayToMap(program.getSourceFiles(), sourceFile => sourceFile.path),
@@ -138,32 +122,34 @@ namespace ts {
             );
         }
 
-        function registerChangedFile(path: Path, fileName: string) {
-            changedFileNames.set(path, fileName);
+        function registerChangedFile(path: Path) {
+            changedFilesSet.set(path, true);
             // All changed files need to re-evaluate its semantic diagnostics
             semanticDiagnosticsPerFile.delete(path);
         }
 
         function addNewFileInfo(program: Program, sourceFile: SourceFile): FileInfo {
-            registerChangedFile(sourceFile.path, sourceFile.fileName);
+            registerChangedFile(sourceFile.path);
             emitHandler.onAddSourceFile(program, sourceFile);
-            return { fileName: sourceFile.fileName, version: sourceFile.version, signature: undefined };
+            return { version: sourceFile.version, signature: undefined };
         }
 
-        function removeExistingFileInfo(existingFileInfo: FileInfo, path: Path) {
-            registerChangedFile(path, existingFileInfo.fileName);
+        function removeExistingFileInfo(_existingFileInfo: FileInfo, path: Path) {
+            // Since we dont need to track removed file as changed file
+            // We can just remove its diagnostics
+            changedFilesSet.delete(path);
+            semanticDiagnosticsPerFile.delete(path);
             emitHandler.onRemoveSourceFile(path);
         }
 
         function updateExistingFileInfo(program: Program, existingInfo: FileInfo, sourceFile: SourceFile) {
             if (existingInfo.version !== sourceFile.version) {
-                registerChangedFile(sourceFile.path, sourceFile.fileName);
+                registerChangedFile(sourceFile.path);
                 existingInfo.version = sourceFile.version;
                 emitHandler.onUpdateSourceFile(program, sourceFile);
             }
-            else if (program.hasInvalidatedResolution(sourceFile.path) &&
-                emitHandler.onUpdateSourceFileWithSameVersion(program, sourceFile)) {
-                registerChangedFile(sourceFile.path, sourceFile.fileName);
+            else if (emitHandler.onUpdateSourceFileWithSameVersion(program, sourceFile)) {
+                registerChangedFile(sourceFile.path);
             }
         }
 
@@ -179,114 +165,95 @@ namespace ts {
             }
         }
 
-        function getFilesAffectedBy(program: Program, path: Path): string[] {
+        function getFilesAffectedBy(program: Program, path: Path): ReadonlyArray<SourceFile> {
             ensureProgramGraph(program);
 
-            const sourceFile = program.getSourceFile(path);
-            const singleFileResult = sourceFile && options.shouldEmitFile(sourceFile) ? [sourceFile.fileName] : [];
-            const info = fileInfos.get(path);
-            if (!info || !updateShapeSignature(program, sourceFile, info)) {
-                return singleFileResult;
+            const sourceFile = program.getSourceFileByPath(path);
+            if (!sourceFile) {
+                return emptyArray;
             }
 
-            Debug.assert(!!sourceFile);
-            return emitHandler.getFilesAffectedByUpdatedShape(program, sourceFile, singleFileResult);
+            if (!updateShapeSignature(program, sourceFile)) {
+                return [sourceFile];
+            }
+            return emitHandler.getFilesAffectedByUpdatedShape(program, sourceFile);
         }
 
-        function emitFile(program: Program, path: Path) {
+        function emitChangedFiles(program: Program, writeFileCallback: WriteFileCallback): ReadonlyArray<EmitResult> {
             ensureProgramGraph(program);
-            if (!fileInfos.has(path)) {
-                return { outputFiles: [], emitSkipped: true };
+            const compilerOptions = program.getCompilerOptions();
+
+            if (!changedFilesSet.size) {
+                return emptyArray;
             }
 
-            return options.getEmitOutput(program, program.getSourceFileByPath(path), /*emitOnlyDtsFiles*/ false, /*isDetailed*/ false);
-        }
+            // With --out or --outFile all outputs go into single file, do it only once
+            if (compilerOptions.outFile || compilerOptions.out) {
+                Debug.assert(semanticDiagnosticsPerFile.size === 0);
+                changedFilesSet.clear();
+                return [program.emit(/*targetSourceFile*/ undefined, writeFileCallback)];
+            }
 
-        function enumerateChangedFilesSet(
-            program: Program,
-            onChangedFile: (fileName: string, path: Path) => void,
-            onAffectedFile: (fileName: string, sourceFile: SourceFile) => void
-        ) {
-            changedFileNames.forEach((fileName, path) => {
-                onChangedFile(fileName, path as Path);
-                const affectedFiles = getFilesAffectedBy(program, path as Path);
-                for (const file of affectedFiles) {
-                    onAffectedFile(file, program.getSourceFile(file));
-                }
-            });
-        }
-
-        function enumerateChangedFilesEmitOutput(
-            program: Program,
-            emitOnlyDtsFiles: boolean,
-            onChangedFile: (fileName: string, path: Path) => void,
-            onEmitOutput: (emitOutput: EmitOutputDetailed, sourceFile: SourceFile) => void
-        ) {
             const seenFiles = createMap<true>();
-            enumerateChangedFilesSet(program, onChangedFile, (fileName, sourceFile) => {
-                if (!seenFiles.has(fileName)) {
-                    seenFiles.set(fileName, true);
-                    if (sourceFile) {
-                        // Any affected file shouldnt have the cached diagnostics
-                        semanticDiagnosticsPerFile.delete(sourceFile.path);
+            let result: EmitResult[] | undefined;
+            changedFilesSet.forEach((_true, path) => {
+                // Get the affected Files by this program
+                const affectedFiles = getFilesAffectedBy(program, path as Path);
+                affectedFiles.forEach(affectedFile => {
+                    // Affected files shouldnt have cached diagnostics
+                    semanticDiagnosticsPerFile.delete(affectedFile.path);
 
-                        const emitOutput = options.getEmitOutput(program, sourceFile, emitOnlyDtsFiles, /*isDetailed*/ true) as EmitOutputDetailed;
-                        onEmitOutput(emitOutput, sourceFile);
+                    if (!seenFiles.has(affectedFile.path)) {
+                        seenFiles.set(affectedFile.path, true);
 
-                        // mark all the emitted source files as seen
-                        if (emitOutput.emittedSourceFiles) {
-                            for (const file of emitOutput.emittedSourceFiles) {
-                                seenFiles.set(file.fileName, true);
-                            }
-                        }
+                        // Emit the affected file
+                        (result || (result = [])).push(program.emit(affectedFile, writeFileCallback));
                     }
-                }
+                });
             });
+            changedFilesSet.clear();
+            return result || emptyArray;
         }
 
-        function emitChangedFiles(program: Program): EmitOutputDetailed[] {
+        function getSemanticDiagnostics(program: Program, cancellationToken?: CancellationToken): ReadonlyArray<Diagnostic> {
             ensureProgramGraph(program);
-            const result: EmitOutputDetailed[] = [];
-            enumerateChangedFilesEmitOutput(program, /*emitOnlyDtsFiles*/ false,
-                /*onChangedFile*/ noop, emitOutput => result.push(emitOutput));
-            changedFileNames.clear();
-            return result;
-        }
+            Debug.assert(changedFilesSet.size === 0);
 
-        function getSemanticDiagnostics(program: Program, cancellationToken?: CancellationToken): Diagnostic[] {
-            ensureProgramGraph(program);
-
-            // Ensure that changed files have cleared their respective
-            enumerateChangedFilesSet(program, /*onChangedFile*/ noop, (_affectedFileName, sourceFile) => {
-                if (sourceFile) {
-                    semanticDiagnosticsPerFile.delete(sourceFile.path);
-                }
-            });
+            const compilerOptions = program.getCompilerOptions();
+            if (compilerOptions.outFile || compilerOptions.out) {
+                Debug.assert(semanticDiagnosticsPerFile.size === 0);
+                // We dont need to cache the diagnostics just return them from program
+                return program.getSemanticDiagnostics(/*sourceFile*/ undefined, cancellationToken);
+            }
 
             let diagnostics: Diagnostic[];
             for (const sourceFile of program.getSourceFiles()) {
-                const path = sourceFile.path;
-                const cachedDiagnostics = semanticDiagnosticsPerFile.get(path);
-                // Report the semantic diagnostics from the cache if we already have those diagnostics present
-                if (cachedDiagnostics) {
-                    diagnostics = addRange(diagnostics, cachedDiagnostics);
-                }
-                else {
-                    // Diagnostics werent cached, get them from program, and cache the result
-                    const cachedDiagnostics = program.getSemanticDiagnostics(sourceFile, cancellationToken);
-                    semanticDiagnosticsPerFile.set(path, cachedDiagnostics);
-                    diagnostics = addRange(diagnostics, cachedDiagnostics);
-                }
+                diagnostics = addRange(diagnostics, getSemanticDiagnosticsOfFile(program, sourceFile, cancellationToken));
             }
             return diagnostics || emptyArray;
         }
 
+        function getSemanticDiagnosticsOfFile(program: Program, sourceFile: SourceFile, cancellationToken?: CancellationToken): ReadonlyArray<Diagnostic> {
+            const path = sourceFile.path;
+            const cachedDiagnostics = semanticDiagnosticsPerFile.get(path);
+            // Report the semantic diagnostics from the cache if we already have those diagnostics present
+            if (cachedDiagnostics) {
+                return cachedDiagnostics;
+            }
+
+            // Diagnostics werent cached, get them from program, and cache the result
+            const diagnostics = program.getSemanticDiagnostics(sourceFile, cancellationToken);
+            semanticDiagnosticsPerFile.set(path, diagnostics);
+            return diagnostics;
+        }
+
         function clear() {
             isModuleEmit = undefined;
             emitHandler = undefined;
             fileInfos.clear();
             semanticDiagnosticsPerFile.clear();
-            changedFileNames.clear();
+            changedFilesSet.clear();
+            hasShapeChanged.clear();
         }
 
         /**
@@ -307,15 +274,26 @@ namespace ts {
         /**
          * @return {boolean} indicates if the shape signature has changed since last update.
          */
-        function updateShapeSignature(program: Program, sourceFile: SourceFile, info: FileInfo) {
+        function updateShapeSignature(program: Program, sourceFile: SourceFile) {
+            Debug.assert(!!sourceFile);
+
+            // If we have cached the result for this file, that means hence forth we should assume file shape is uptodate
+            if (hasShapeChanged.has(sourceFile.path)) {
+                return false;
+            }
+
+            hasShapeChanged.set(sourceFile.path, true);
+            const info = fileInfos.get(sourceFile.path);
+            Debug.assert(!!info);
+
             const prevSignature = info.signature;
             let latestSignature: string;
             if (sourceFile.isDeclarationFile) {
-                latestSignature = options.computeHash(sourceFile.text);
+                latestSignature = sourceFile.version;
                 info.signature = latestSignature;
             }
             else {
-                const emitOutput = options.getEmitOutput(program, sourceFile, /*emitOnlyDtsFiles*/ true, /*isDetailed*/ false);
+                const emitOutput = getFileEmitOutput(program, sourceFile, /*emitOnlyDtsFiles*/ true);
                 if (emitOutput.outputFiles && emitOutput.outputFiles.length > 0) {
                     latestSignature = options.computeHash(emitOutput.outputFiles[0].text);
                     info.signature = latestSignature;
@@ -383,24 +361,27 @@ namespace ts {
         }
 
         /**
-         * Gets all the emittable files from the program.
-         * @param firstSourceFile This one will be emitted first. See https://github.com/Microsoft/TypeScript/issues/16888
+         * Gets all files of the program excluding the default library file
          */
-        function getAllEmittableFiles(program: Program, firstSourceFile: SourceFile): string[] {
-            const defaultLibraryFileName = getDefaultLibFileName(program.getCompilerOptions());
-            const sourceFiles = program.getSourceFiles();
-            const result: string[] = [];
-            add(firstSourceFile);
-            for (const sourceFile of sourceFiles) {
+        function getAllFilesExcludingDefaultLibraryFile(program: Program, firstSourceFile: SourceFile): ReadonlyArray<SourceFile> {
+            // Use cached result
+            if (allFilesExcludingDefaultLibraryFile) {
+                return allFilesExcludingDefaultLibraryFile;
+            }
+
+            let result: SourceFile[];
+            addSourceFile(firstSourceFile);
+            for (const sourceFile of program.getSourceFiles()) {
                 if (sourceFile !== firstSourceFile) {
-                    add(sourceFile);
+                    addSourceFile(sourceFile);
                 }
             }
-            return result;
+            allFilesExcludingDefaultLibraryFile = result || emptyArray;
+            return allFilesExcludingDefaultLibraryFile;
 
-            function add(sourceFile: SourceFile): void {
-                if (getBaseFileName(sourceFile.fileName) !== defaultLibraryFileName && options.shouldEmitFile(sourceFile)) {
-                    result.push(sourceFile.fileName);
+            function addSourceFile(sourceFile: SourceFile) {
+                if (!program.isSourceFileDefaultLibrary(sourceFile)) {
+                    (result || (result = [])).push(sourceFile);
                 }
             }
         }
@@ -414,14 +395,14 @@ namespace ts {
                 getFilesAffectedByUpdatedShape
             };
 
-            function getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile, singleFileResult: string[]): string[] {
+            function getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile): ReadonlyArray<SourceFile> {
                 const options = program.getCompilerOptions();
                 // If `--out` or `--outFile` is specified, any new emit will result in re-emitting the entire project,
                 // so returning the file itself is good enough.
                 if (options && (options.out || options.outFile)) {
-                    return singleFileResult;
+                    return [sourceFile];
                 }
-                return getAllEmittableFiles(program, sourceFile);
+                return getAllFilesExcludingDefaultLibraryFile(program, sourceFile);
             }
         }
 
@@ -478,7 +459,7 @@ namespace ts {
                         // add files referencing the removedFilePath, as changed files too
                         const referencedByInfo = fileInfos.get(filePath);
                         if (referencedByInfo) {
-                            registerChangedFile(filePath as Path, referencedByInfo.fileName);
+                            registerChangedFile(filePath as Path);
                         }
                     }
                 });
@@ -492,37 +473,33 @@ namespace ts {
                 );
             }
 
-            function getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile, singleFileResult: string[]): string[] {
+            function getFilesAffectedByUpdatedShape(program: Program, sourceFile: SourceFile): ReadonlyArray<SourceFile> {
                 if (!isExternalModule(sourceFile) && !containsOnlyAmbientModules(sourceFile)) {
-                    return getAllEmittableFiles(program, sourceFile);
+                    return getAllFilesExcludingDefaultLibraryFile(program, sourceFile);
                 }
 
                 const compilerOptions = program.getCompilerOptions();
                 if (compilerOptions && (compilerOptions.isolatedModules || compilerOptions.out || compilerOptions.outFile)) {
-                    return singleFileResult;
+                    return [sourceFile];
                 }
 
                 // Now we need to if each file in the referencedBy list has a shape change as well.
                 // Because if so, its own referencedBy files need to be saved as well to make the
                 // emitting result consistent with files on disk.
-
-                const seenFileNamesMap = createMap<string>();
-                const setSeenFileName = (path: Path, sourceFile: SourceFile) => {
-                    seenFileNamesMap.set(path, sourceFile && options.shouldEmitFile(sourceFile) ? sourceFile.fileName : undefined);
-                };
+                const seenFileNamesMap = createMap<SourceFile>();
 
                 // Start with the paths this file was referenced by
                 const path = sourceFile.path;
-                setSeenFileName(path, sourceFile);
+                seenFileNamesMap.set(path, sourceFile);
                 const queue = getReferencedByPaths(path);
                 while (queue.length > 0) {
                     const currentPath = queue.pop();
                     if (!seenFileNamesMap.has(currentPath)) {
                         const currentSourceFile = program.getSourceFileByPath(currentPath);
-                        if (currentSourceFile && updateShapeSignature(program, currentSourceFile, fileInfos.get(currentPath))) {
+                        seenFileNamesMap.set(currentPath, currentSourceFile);
+                        if (currentSourceFile && updateShapeSignature(program, currentSourceFile)) {
                             queue.push(...getReferencedByPaths(currentPath));
                         }
-                        setSeenFileName(currentPath, currentSourceFile);
                     }
                 }
 

src/compiler/commandLineParser.ts

@@ -1183,8 +1183,8 @@ namespace ts {
             }
         }
 
-        function isDoubleQuotedString(node: Node) {
-            return node.kind === SyntaxKind.StringLiteral && getSourceTextOfNodeFromSourceFile(sourceFile, node).charCodeAt(0) === CharacterCodes.doubleQuote;
+        function isDoubleQuotedString(node: Node): boolean {
+            return isStringLiteral(node) && isStringDoubleQuoted(node, sourceFile);
         }
     }
 
@@ -1440,9 +1440,9 @@ namespace ts {
 
         function getFileNames(): ExpandResult {
             let filesSpecs: ReadonlyArray<string>;
-            if (hasProperty(raw, "files") && !isNullOrUndefined(raw["files"])) {
-                if (isArray(raw["files"])) {
-                    filesSpecs = <ReadonlyArray<string>>raw["files"];
+            if (hasProperty(raw, "files") && !isNullOrUndefined(raw.files)) {
+                if (isArray(raw.files)) {
+                    filesSpecs = <ReadonlyArray<string>>raw.files;
                     if (filesSpecs.length === 0) {
                         createCompilerDiagnosticOnlyIfJson(Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json");
                     }
@@ -1453,9 +1453,9 @@ namespace ts {
             }
 
             let includeSpecs: ReadonlyArray<string>;
-            if (hasProperty(raw, "include") && !isNullOrUndefined(raw["include"])) {
-                if (isArray(raw["include"])) {
-                    includeSpecs = <ReadonlyArray<string>>raw["include"];
+            if (hasProperty(raw, "include") && !isNullOrUndefined(raw.include)) {
+                if (isArray(raw.include)) {
+                    includeSpecs = <ReadonlyArray<string>>raw.include;
                 }
                 else {
                     createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "include", "Array");
@@ -1463,16 +1463,16 @@ namespace ts {
             }
 
             let excludeSpecs: ReadonlyArray<string>;
-            if (hasProperty(raw, "exclude") && !isNullOrUndefined(raw["exclude"])) {
-                if (isArray(raw["exclude"])) {
-                    excludeSpecs = <ReadonlyArray<string>>raw["exclude"];
+            if (hasProperty(raw, "exclude") && !isNullOrUndefined(raw.exclude)) {
+                if (isArray(raw.exclude)) {
+                    excludeSpecs = <ReadonlyArray<string>>raw.exclude;
                 }
                 else {
                     createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "exclude", "Array");
                 }
             }
             else {
-                const outDir = raw["compilerOptions"] && raw["compilerOptions"]["outDir"];
+                const outDir = raw.compilerOptions && raw.compilerOptions.outDir;
                 if (outDir) {
                     excludeSpecs = [outDir];
                 }
@@ -1591,7 +1591,7 @@ namespace ts {
         const options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName);
         // typingOptions has been deprecated and is only supported for backward compatibility purposes.
         // It should be removed in future releases - use typeAcquisition instead.
-        const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json["typeAcquisition"] || json["typingOptions"], basePath, errors, configFileName);
+        const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName);
         json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
         let extendedConfigPath: Path;
 
@@ -1748,7 +1748,7 @@ namespace ts {
         if (!hasProperty(jsonOption, compileOnSaveCommandLineOption.name)) {
             return undefined;
         }
-        const result = convertJsonOption(compileOnSaveCommandLineOption, jsonOption["compileOnSave"], basePath, errors);
+        const result = convertJsonOption(compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors);
         if (typeof result === "boolean" && result) {
             return result;
         }

src/compiler/core.ts

@@ -4,7 +4,7 @@
 namespace ts {
     // WARNING: The script `configureNightly.ts` uses a regexp to parse out these values.
     // If changing the text in this section, be sure to test `configureNightly` too.
-    export const versionMajorMinor = "2.6";
+    export const versionMajorMinor = "2.7";
     /** The version of the TypeScript compiler release */
     export const version = `${versionMajorMinor}.0`;
 }
@@ -33,8 +33,8 @@ namespace ts {
         // 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["__"];
+        map.__ = undefined;
+        delete map.__;
 
         return map;
     }
@@ -191,6 +191,18 @@ namespace ts {
         }
         return undefined;
     }
+
+    /** Like `forEach`, but suitable for use with numbers and strings (which may be falsy). */
+    export function firstDefined<T, U>(array: ReadonlyArray<T> | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {
+        for (let i = 0; i < array.length; i++) {
+            const result = callback(array[i], i);
+            if (result !== undefined) {
+                return result;
+            }
+        }
+        return undefined;
+    }
+
     /**
      * Iterates through the parent chain of a node and performs the callback on each parent until the callback
      * returns a truthy value, then returns that value.
@@ -213,11 +225,13 @@ namespace ts {
         return undefined;
     }
 
-    export function zipWith<T, U>(arrayA: ReadonlyArray<T>, arrayB: ReadonlyArray<U>, callback: (a: T, b: U, index: number) => void): void {
+    export function zipWith<T, U, V>(arrayA: ReadonlyArray<T>, arrayB: ReadonlyArray<U>, callback: (a: T, b: U, index: number) => V): V[] {
+        const result: V[] = [];
         Debug.assert(arrayA.length === arrayB.length);
         for (let i = 0; i < arrayA.length; i++) {
-            callback(arrayA[i], arrayB[i], i);
+            result.push(callback(arrayA[i], arrayB[i], i));
         }
+        return result;
     }
 
     export function zipToMap<T>(keys: ReadonlyArray<string>, values: ReadonlyArray<T>): Map<T> {
@@ -259,6 +273,16 @@ namespace ts {
         return undefined;
     }
 
+    export function findLast<T>(array: ReadonlyArray<T>, predicate: (element: T, index: number) => boolean): T | undefined {
+        for (let i = array.length - 1; i >= 0; i--) {
+            const value = array[i];
+            if (predicate(value, i)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+
     /** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
     export function findIndex<T>(array: ReadonlyArray<T>, predicate: (element: T, index: number) => boolean): number {
         for (let i = 0; i < array.length; i++) {
@@ -356,21 +380,6 @@ namespace ts {
         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, i: number, array: T[]) => boolean): void {
         let outIndex = 0;
         for (let i = 0; i < array.length; i++) {
@@ -1160,6 +1169,14 @@ namespace ts {
         return result;
     }
 
+    export function arrayToNumericMap<T>(array: ReadonlyArray<T>, makeKey: (value: T) => number): T[] {
+        const result: T[] = [];
+        for (const value of array) {
+            result[makeKey(value)] = value;
+        }
+        return result;
+    }
+
     /**
      * Creates a set from the elements of an array.
      *
@@ -1663,7 +1680,7 @@ namespace ts {
     }
 
     export function isUrl(path: string) {
-        return path && !isRootedDiskPath(path) && path.indexOf("://") !== -1;
+        return path && !isRootedDiskPath(path) && stringContains(path, "://");
     }
 
     export function pathIsRelative(path: string): boolean {
@@ -1844,7 +1861,7 @@ namespace ts {
         return i < 0 ? path : path.substring(i + 1);
     }
 
-    export function combinePaths(path1: string, path2: string) {
+    export function combinePaths(path1: string, path2: string): string {
         if (!(path1 && path1.length)) return path2;
         if (!(path2 && path2.length)) return path1;
         if (getRootLength(path2) !== 0) return path2;
@@ -1932,8 +1949,12 @@ namespace ts {
         return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
     }
 
+    export function stringContains(str: string, substring: string): boolean {
+        return str.indexOf(substring) !== -1;
+    }
+
     export function hasExtension(fileName: string): boolean {
-        return getBaseFileName(fileName).indexOf(".") >= 0;
+        return stringContains(getBaseFileName(fileName), ".");
     }
 
     export function fileExtensionIs(path: string, extension: string): boolean {
@@ -2670,6 +2691,16 @@ namespace ts {
         return find<Extension>(supportedTypescriptExtensionsForExtractExtension, e => fileExtensionIs(path, e)) || find(supportedJavascriptExtensions, e => fileExtensionIs(path, e));
     }
 
+    // Retrieves any string from the final "." onwards from a base file name.
+    // Unlike extensionFromPath, which throws an exception on unrecognized extensions.
+    export function getAnyExtensionFromPath(path: string): string | undefined {
+        const baseFileName = getBaseFileName(path);
+        const extensionIndex = baseFileName.lastIndexOf(".");
+        if (extensionIndex >= 0) {
+            return baseFileName.substring(extensionIndex);
+        }
+    }
+
     export function isCheckJsEnabledForFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
     }
@@ -2680,8 +2711,14 @@ namespace ts {
 
     export function assertTypeIsNever(_: never): void { }
 
+    export interface FileAndDirectoryExistence {
+        fileExists: boolean;
+        directoryExists: boolean;
+    }
+
     export interface CachedDirectoryStructureHost extends DirectoryStructureHost {
-        addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path): void;
+        /** Returns the queried result for the file exists and directory exists if at all it was done */
+        addOrDeleteFileOrDirectory(fileOrDirectory: string, fileOrDirectoryPath: Path): FileAndDirectoryExistence | undefined;
         addOrDeleteFile(fileName: string, filePath: Path, eventKind: FileWatcherEventKind): void;
         clearCache(): void;
     }
@@ -2851,8 +2888,13 @@ namespace ts {
                 if (parentResult) {
                     const baseName = getBaseNameOfFileName(fileOrDirectory);
                     if (parentResult) {
-                        updateFilesOfFileSystemEntry(parentResult, baseName, host.fileExists(fileOrDirectoryPath));
-                        updateFileSystemEntry(parentResult.directories, baseName, host.directoryExists(fileOrDirectoryPath));
+                        const fsQueryResult: FileAndDirectoryExistence = {
+                            fileExists: host.fileExists(fileOrDirectoryPath),
+                            directoryExists: host.directoryExists(fileOrDirectoryPath)
+                        };
+                        updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists);
+                        updateFileSystemEntry(parentResult.directories, baseName, fsQueryResult.directoryExists);
+                        return fsQueryResult;
                     }
                 }
             }

src/compiler/declarationEmitter.ts

@@ -172,7 +172,7 @@ namespace ts {
 
         function hasInternalAnnotation(range: CommentRange) {
             const comment = currentText.substring(range.pos, range.end);
-            return comment.indexOf("@internal") >= 0;
+            return stringContains(comment, "@internal");
         }
 
         function stripInternal(node: Node) {

src/compiler/diagnosticMessages.json

@@ -1340,7 +1340,7 @@
         "category": "Error",
         "code": 2402
     },
-    "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'.": {
+    "Subsequent variable declarations must have the same type.  Variable '{0}' has type '{1}' at {2}, but here has type '{3}'.": {
         "category": "Error",
         "code": 2403
     },
@@ -2244,14 +2244,22 @@
         "category": "Error",
         "code": 2714
     },
-    "Subsequent property declarations must have the same type.  Property '{0}' must be of type '{1}', but here has type '{2}'.": {
+    "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor.": {
         "category": "Error",
         "code": 2715
     },
-    "Duplicate declaration '{0}'.": {
+    "Type parameter '{0}' has a circular default.": {
         "category": "Error",
         "code": 2716
     },
+    "Subsequent property declarations must have the same type.  Property '{0}' has type '{1}' at {2}, but here has type '{3}'.": {
+        "category": "Error",
+        "code": 2717
+    },
+    "Duplicate declaration '{0}'.": {
+        "category": "Error",
+        "code": 2718
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -3547,11 +3555,11 @@
         "category": "Error",
         "code": 8021
     },
-    "JSDoc '@augments' is not attached to a class declaration.": {
+    "JSDoc '@{0}' is not attached to a class.": {
         "category": "Error",
         "code": 8022
     },
-    "JSDoc '@augments {0}' does not match the 'extends {1}' clause.": {
+    "JSDoc '@{0} {1}' does not match the 'extends {2}' clause.": {
         "category": "Error",
         "code": 8023
     },
@@ -3559,6 +3567,18 @@
         "category": "Error",
         "code": 8024
     },
+    "Class declarations cannot have more than one `@augments` or `@extends` tag.": {
+        "category": "Error",
+        "code": 8025
+    },
+    "Expected {0} type arguments; provide these with an '@extends' tag.": {
+        "category": "Error",
+        "code": 8026
+    },
+    "Expected {0}-{1} type arguments; provide these with an '@extends' tag.": {
+        "category": "Error",
+        "code": 8027
+    },
     "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause.": {
         "category": "Error",
         "code": 9002
@@ -3681,15 +3701,15 @@
         "category": "Error",
         "code": 90010
     },
-    "Import {0} from {1}.": {
+    "Import '{0}' from \"{1}\".": {
         "category": "Message",
         "code": 90013
     },
-    "Change {0} to {1}.": {
+    "Change '{0}' to '{1}'.": {
         "category": "Message",
         "code": 90014
     },
-    "Add {0} to existing import declaration from {1}.": {
+    "Add '{0}' to existing import declaration from \"{1}\".": {
         "category": "Message",
         "code": 90015
     },
@@ -3701,6 +3721,7 @@
         "category": "Message",
         "code": 90017
     },
+
     "Disable checking for this file.": {
         "category": "Message",
         "code": 90018
@@ -3741,7 +3762,10 @@
         "category": "Message",
         "code": 90027
     },
-
+    "Call decorator expression.": {
+        "category": "Message",
+        "code": 90028
+    },
     "Convert function to an ES2015 class": {
         "category": "Message",
         "code": 95001
@@ -3750,34 +3774,44 @@
         "category": "Message",
         "code": 95002
     },
-
     "Extract symbol": {
         "category": "Message",
         "code": 95003
     },
-
     "Extract to {0} in {1}": {
         "category": "Message",
         "code": 95004
     },
-
     "Extract function": {
         "category": "Message",
         "code": 95005
     },
-
     "Extract constant": {
         "category": "Message",
         "code": 95006
     },
-
     "Extract to {0} in enclosing scope": {
         "category": "Message",
         "code": 95007
     },
-
     "Extract to {0} in {1} scope": {
         "category": "Message",
         "code": 95008
+    },
+    "Annotate with type from JSDoc": {
+        "category": "Message",
+        "code": 95009
+    },
+    "Annotate with types from JSDoc": {
+        "category": "Message",
+        "code": 95010
+    },
+    "Infer type of '{0}' from usage.": {
+        "category": "Message",
+        "code": 95011
+    },
+    "Infer parameter types from usage.": {
+        "category": "Message",
+        "code": 95012
     }
 }

src/compiler/emitter.ts

@@ -546,6 +546,8 @@ namespace ts {
                     return emitTypeReference(<TypeReferenceNode>node);
                 case SyntaxKind.FunctionType:
                     return emitFunctionType(<FunctionTypeNode>node);
+                case SyntaxKind.JSDocFunctionType:
+                    return emitJSDocFunctionType(node as JSDocFunctionType);
                 case SyntaxKind.ConstructorType:
                     return emitConstructorType(<ConstructorTypeNode>node);
                 case SyntaxKind.TypeQuery:
@@ -574,6 +576,20 @@ namespace ts {
                     return emitMappedType(<MappedTypeNode>node);
                 case SyntaxKind.LiteralType:
                     return emitLiteralType(<LiteralTypeNode>node);
+                case SyntaxKind.JSDocAllType:
+                    write("*");
+                    return;
+                case SyntaxKind.JSDocUnknownType:
+                    write("?");
+                    return;
+                case SyntaxKind.JSDocNullableType:
+                    return emitJSDocNullableType(node as JSDocNullableType);
+                case SyntaxKind.JSDocNonNullableType:
+                    return emitJSDocNonNullableType(node as JSDocNonNullableType);
+                case SyntaxKind.JSDocOptionalType:
+                    return emitJSDocOptionalType(node as JSDocOptionalType);
+                case SyntaxKind.JSDocVariadicType:
+                    return emitJSDocVariadicType(node as JSDocVariadicType);
 
                 // Binding patterns
                 case SyntaxKind.ObjectBindingPattern:
@@ -914,9 +930,16 @@ namespace ts {
             emitDecorators(node, node.decorators);
             emitModifiers(node, node.modifiers);
             emitIfPresent(node.dotDotDotToken);
-            emit(node.name);
+            if (node.name) {
+                emit(node.name);
+            }
             emitIfPresent(node.questionToken);
-            emitWithPrefix(": ", node.type);
+            if (node.parent && node.parent.kind === SyntaxKind.JSDocFunctionType && !node.name) {
+                emit(node.type);
+            }
+            else {
+                emitWithPrefix(": ", node.type);
+            }
             emitExpressionWithPrefix(" = ", node.initializer);
         }
 
@@ -1035,6 +1058,29 @@ namespace ts {
             emit(node.type);
         }
 
+        function emitJSDocFunctionType(node: JSDocFunctionType) {
+            write("function");
+            emitParameters(node, node.parameters);
+            write(":");
+            emit(node.type);
+        }
+
+
+        function emitJSDocNullableType(node: JSDocNullableType) {
+            write("?");
+            emit(node.type);
+        }
+
+        function emitJSDocNonNullableType(node: JSDocNonNullableType) {
+            write("!");
+            emit(node.type);
+        }
+
+        function emitJSDocOptionalType(node: JSDocOptionalType) {
+            emit(node.type);
+            write("=");
+        }
+
         function emitConstructorType(node: ConstructorTypeNode) {
             write("new ");
             emitTypeParameters(node, node.typeParameters);
@@ -1060,6 +1106,11 @@ namespace ts {
             write("[]");
         }
 
+        function emitJSDocVariadicType(node: JSDocVariadicType) {
+            write("...");
+            emit(node.type);
+        }
+
         function emitTupleType(node: TupleTypeNode) {
             write("[");
             emitList(node, node.elementTypes, ListFormat.TupleTypeElements);
@@ -1226,7 +1277,7 @@ namespace ts {
                 // check if numeric literal is a decimal literal that was originally written with a dot
                 const text = getLiteralTextOfNode(<LiteralExpression>expression);
                 return !expression.numericLiteralFlags
-                    && text.indexOf(tokenToString(SyntaxKind.DotToken)) < 0;
+                    && !stringContains(text, tokenToString(SyntaxKind.DotToken));
             }
             else if (isPropertyAccessExpression(expression) || isElementAccessExpression(expression)) {
                 // check if constant enum value is integer

src/compiler/factory.ts

@@ -47,10 +47,15 @@ namespace ts {
      * Creates a shallow, memberwise clone of a node with no source map location.
      */
     /* @internal */
-    export function getSynthesizedClone<T extends Node>(node: T | undefined): T {
+    export function getSynthesizedClone<T extends Node>(node: T | undefined): T | undefined {
         // We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
         // the original node. We also need to exclude specific properties and only include own-
         // properties (to skip members already defined on the shared prototype).
+
+        if (node === undefined) {
+            return undefined;
+        }
+
         const clone = <T>createSynthesizedNode(node.kind);
         clone.flags |= node.flags;
         setOriginalNode(clone, node);
@@ -2609,6 +2614,16 @@ namespace ts {
         return node;
     }
 
+    /**
+     * Sets flags that control emit behavior of a node.
+     */
+    /* @internal */
+    export function addEmitFlags<T extends Node>(node: T, emitFlags: EmitFlags) {
+        const emitNode = getOrCreateEmitNode(node);
+        emitNode.flags = emitNode.flags | emitFlags;
+        return node;
+    }
+
     /**
      * Gets a custom text range to use when emitting source maps.
      */

src/compiler/moduleNameResolver.ts

@@ -77,16 +77,20 @@ namespace ts {
         traceEnabled: boolean;
     }
 
-    interface PackageJson {
-        name?: string;
-        version?: string;
+    /** Just the fields that we use for module resolution. */
+    interface PackageJsonPathFields {
         typings?: string;
         types?: string;
         main?: string;
     }
 
+    interface PackageJson extends PackageJsonPathFields {
+        name?: string;
+        version?: string;
+    }
+
     /** Reads from "main" or "types"/"typings" depending on `extensions`. */
-    function tryReadPackageJsonFields(readTypes: boolean, jsonContent: PackageJson, baseDirectory: string, state: ModuleResolutionState): string | undefined {
+    function tryReadPackageJsonFields(readTypes: boolean, jsonContent: PackageJsonPathFields, baseDirectory: string, state: ModuleResolutionState): string | undefined {
         return readTypes ? tryReadFromField("typings") || tryReadFromField("types") : tryReadFromField("main");
 
         function tryReadFromField(fieldName: "typings" | "types" | "main"): string | undefined {
@@ -124,7 +128,11 @@ namespace ts {
         }
     }
 
-    export function getEffectiveTypeRoots(options: CompilerOptions, host: { directoryExists?: (directoryName: string) => boolean, getCurrentDirectory?: () => string }): string[] | undefined {
+    export interface GetEffectiveTypeRootsHost {
+        directoryExists?(directoryName: string): boolean;
+        getCurrentDirectory?(): string;
+    }
+    export function getEffectiveTypeRoots(options: CompilerOptions, host: GetEffectiveTypeRootsHost): string[] | undefined {
         if (options.typeRoots) {
             return options.typeRoots;
         }
@@ -886,7 +894,7 @@ namespace ts {
         return withPackageId(packageId, loadNodeModuleFromDirectoryWorker(extensions, candidate, failedLookupLocations, onlyRecordFailures, state, packageJsonContent));
     }
 
-    function loadNodeModuleFromDirectoryWorker(extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState, packageJsonContent: PackageJson | undefined): PathAndExtension | undefined {
+    function loadNodeModuleFromDirectoryWorker(extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState, packageJsonContent: PackageJsonPathFields | undefined): PathAndExtension | undefined {
         const fromPackageJson = packageJsonContent && loadModuleFromPackageJson(packageJsonContent, extensions, candidate, failedLookupLocations, state);
         if (fromPackageJson) {
             return fromPackageJson;
@@ -901,7 +909,7 @@ namespace ts {
         failedLookupLocations: Push<string>,
         onlyRecordFailures: boolean,
         { host, traceEnabled }: ModuleResolutionState,
-    ): { packageJsonContent: PackageJson | undefined, packageId: PackageId | undefined } {
+    ): { found: boolean, packageJsonContent: PackageJsonPathFields | undefined, packageId: PackageId | undefined } {
         const directoryExists = !onlyRecordFailures && directoryProbablyExists(nodeModuleDirectory, host);
         const packageJsonPath = pathToPackageJson(nodeModuleDirectory);
         if (directoryExists && host.fileExists(packageJsonPath)) {
@@ -912,7 +920,7 @@ namespace ts {
             const packageId: PackageId = typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string"
                 ? { name: packageJsonContent.name, subModuleName, version: packageJsonContent.version }
                 : undefined;
-            return { packageJsonContent, packageId };
+            return { found: true, packageJsonContent, packageId };
         }
         else {
             if (directoryExists && traceEnabled) {
@@ -920,11 +928,11 @@ namespace ts {
             }
             // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results
             failedLookupLocations.push(packageJsonPath);
-            return { packageJsonContent: undefined, packageId: undefined };
+            return { found: false, packageJsonContent: undefined, packageId: undefined };
         }
     }
 
-    function loadModuleFromPackageJson(jsonContent: PackageJson, extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): PathAndExtension | undefined {
+    function loadModuleFromPackageJson(jsonContent: PackageJsonPathFields, extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): PathAndExtension | undefined {
         const file = tryReadPackageJsonFields(extensions !== Extensions.JavaScript, jsonContent, candidate, state);
         if (!file) {
             return undefined;
@@ -976,16 +984,29 @@ namespace ts {
     }
 
     function loadModuleFromNodeModulesFolder(extensions: Extensions, moduleName: string, nodeModulesFolder: string, nodeModulesFolderExists: boolean, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
-        const { packageName, rest } = getPackageName(moduleName);
-        const packageRootPath = combinePaths(nodeModulesFolder, packageName);
-        const { packageJsonContent, packageId } = getPackageJsonInfo(packageRootPath, rest, failedLookupLocations, !nodeModulesFolderExists, state);
         const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
+        // First look for a nested package.json, as in `node_modules/foo/bar/package.json`.
+        let packageJsonContent: PackageJsonPathFields | undefined;
+        let packageId: PackageId | undefined;
+        const packageInfo = getPackageJsonInfo(candidate, "", failedLookupLocations, /*onlyRecordFailures*/ !nodeModulesFolderExists, state);
+        if (packageInfo.found) {
+            ({ packageJsonContent, packageId } = packageInfo);
+        }
+        else {
+            const { packageName, rest } = getPackageName(moduleName);
+            if (rest !== "") { // If "rest" is empty, we just did this search above.
+                const packageRootPath = combinePaths(nodeModulesFolder, packageName);
+                // Don't use a "types" or "main" from here because we're not loading the root, but a subdirectory -- just here for the packageId.
+                packageId = getPackageJsonInfo(packageRootPath, rest, failedLookupLocations, !nodeModulesFolderExists, state).packageId;
+            }
+        }
         const pathAndExtension = loadModuleFromFile(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state) ||
             loadNodeModuleFromDirectoryWorker(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state, packageJsonContent);
         return withPackageId(packageId, pathAndExtension);
     }
 
-    function getPackageName(moduleName: string): { packageName: string, rest: string } {
+    /* @internal */
+    export function getPackageName(moduleName: string): { packageName: string, rest: string } {
         let idx = moduleName.indexOf(directorySeparator);
         if (moduleName[0] === "@") {
             idx = moduleName.indexOf(directorySeparator, idx + 1);
@@ -1043,25 +1064,34 @@ namespace ts {
     const mangledScopedPackageSeparator = "__";
 
     /** For a scoped package, we must look in `@types/foo__bar` instead of `@types/@foo/bar`. */
-    function mangleScopedPackage(moduleName: string, state: ModuleResolutionState): string {
-        if (startsWith(moduleName, "@")) {
-            const replaceSlash = moduleName.replace(ts.directorySeparator, mangledScopedPackageSeparator);
-            if (replaceSlash !== moduleName) {
-                const mangled = replaceSlash.slice(1); // Take off the "@"
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Scoped_package_detected_looking_in_0, mangled);
-                }
-                return mangled;
+    function mangleScopedPackage(packageName: string, state: ModuleResolutionState): string {
+        const mangled = getMangledNameForScopedPackage(packageName);
+        if (state.traceEnabled && mangled !== packageName) {
+            trace(state.host, Diagnostics.Scoped_package_detected_looking_in_0, mangled);
+        }
+        return mangled;
+    }
+
+    /* @internal */
+    export function getTypesPackageName(packageName: string): string {
+        return `@types/${getMangledNameForScopedPackage(packageName)}`;
+    }
+
+    function getMangledNameForScopedPackage(packageName: string): string {
+        if (startsWith(packageName, "@")) {
+            const replaceSlash = packageName.replace(ts.directorySeparator, mangledScopedPackageSeparator);
+            if (replaceSlash !== packageName) {
+                return replaceSlash.slice(1); // Take off the "@"
             }
         }
-        return moduleName;
+        return packageName;
     }
 
     /* @internal */
     export function getPackageNameFromAtTypesDirectory(mangledName: string): string {
         const withoutAtTypePrefix = removePrefix(mangledName, "@types/");
         if (withoutAtTypePrefix !== mangledName) {
-            return withoutAtTypePrefix.indexOf(mangledScopedPackageSeparator) !== -1 ?
+            return stringContains(withoutAtTypePrefix, mangledScopedPackageSeparator) ?
                 "@" + withoutAtTypePrefix.replace(mangledScopedPackageSeparator, ts.directorySeparator) :
                 withoutAtTypePrefix;
         }

src/compiler/parser.ts

@@ -6376,6 +6376,7 @@ namespace ts {
                     if (tagName) {
                         switch (tagName.escapedText) {
                             case "augments":
+                            case "extends":
                                 tag = parseAugmentsTag(atToken, tagName);
                                 break;
                             case "class":
@@ -6702,7 +6703,7 @@ namespace ts {
                             if (typeExpression && typeExpression.type.kind === SyntaxKind.ArrayType) {
                                 jsdocTypeLiteral.isArrayType = true;
                             }
-                            typedefTag.typeExpression = childTypeTag && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
+                            typedefTag.typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ?
                                 childTypeTag.typeExpression :
                                 finishNode(jsdocTypeLiteral);
                         }

src/compiler/program.ts

@@ -663,8 +663,7 @@ namespace ts {
             dropDiagnosticsProducingTypeChecker,
             getSourceFileFromReference,
             sourceFileToPackageName,
-            redirectTargetsSet,
-            hasInvalidatedResolution
+            redirectTargetsSet
         };
 
         verifyCompilerOptions();
@@ -1092,11 +1091,18 @@ namespace ts {
                 return true;
             }
 
-            if (defaultLibraryPath && defaultLibraryPath.length !== 0) {
-                return containsPath(defaultLibraryPath, file.path, currentDirectory, /*ignoreCase*/ !host.useCaseSensitiveFileNames());
+            if (!options.noLib) {
+                return false;
             }
 
-            return compareStrings(file.fileName, getDefaultLibraryFileName(), /*ignoreCase*/ !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
+            // If '--lib' is not specified, include default library file according to '--target'
+            // otherwise, using options specified in '--lib' instead of '--target' default library file
+            if (!options.lib) {
+               return compareStrings(file.fileName, getDefaultLibraryFileName(), /*ignoreCase*/ !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
+            }
+            else {
+                return forEach(options.lib, libFileName => compareStrings(file.fileName, combinePaths(defaultLibraryPath, libFileName), /*ignoreCase*/ !host.useCaseSensitiveFileNames()) === Comparison.EqualTo);
+            }
         }
 
         function getDiagnosticsProducingTypeChecker() {
@@ -1272,8 +1278,10 @@ namespace ts {
                 const typeChecker = getDiagnosticsProducingTypeChecker();
 
                 Debug.assert(!!sourceFile.bindDiagnostics);
-                // For JavaScript files, we don't want to report semantic errors unless explicitly requested.
-                const includeBindAndCheckDiagnostics = !isSourceFileJavaScript(sourceFile) || isCheckJsEnabledForFile(sourceFile, options);
+
+                // By default, only type-check .ts, .tsx, and 'External' files (external files are added by plugins)
+                const includeBindAndCheckDiagnostics = sourceFile.scriptKind === ScriptKind.TS || sourceFile.scriptKind === ScriptKind.TSX ||
+                    sourceFile.scriptKind === ScriptKind.External || isCheckJsEnabledForFile(sourceFile, options);
                 const bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
                 const checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
                 const fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);

src/compiler/resolutionCache.ts

@@ -64,6 +64,7 @@ namespace ts {
     interface DirectoryOfFailedLookupWatch {
         dir: string;
         dirPath: Path;
+        ignore?: true;
     }
 
     export const maxNumberOfFilesToIterateForInvalidation = 256;
@@ -107,7 +108,9 @@ namespace ts {
         return {
             startRecordingFilesWithChangedResolutions,
             finishRecordingFilesWithChangedResolutions,
-            startCachingPerDirectoryResolution,
+            // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
+            // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
+            startCachingPerDirectoryResolution: clearPerDirectoryResolutions,
             finishCachingPerDirectoryResolution,
             resolveModuleNames,
             resolveTypeReferenceDirectives,
@@ -141,7 +144,9 @@ namespace ts {
             resolvedModuleNames.clear();
             resolvedTypeReferenceDirectives.clear();
             allFilesHaveInvalidatedResolution = false;
-            Debug.assert(perDirectoryResolvedModuleNames.size === 0 && perDirectoryResolvedTypeReferenceDirectives.size === 0);
+            // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
+            // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
+            clearPerDirectoryResolutions();
         }
 
         function startRecordingFilesWithChangedResolutions() {
@@ -165,8 +170,9 @@ namespace ts {
             return path => collected && collected.has(path);
         }
 
-        function startCachingPerDirectoryResolution() {
-            Debug.assert(perDirectoryResolvedModuleNames.size === 0 && perDirectoryResolvedTypeReferenceDirectives.size === 0);
+        function clearPerDirectoryResolutions() {
+            perDirectoryResolvedModuleNames.clear();
+            perDirectoryResolvedTypeReferenceDirectives.clear();
         }
 
         function finishCachingPerDirectoryResolution() {
@@ -178,8 +184,7 @@ namespace ts {
                 }
             });
 
-            perDirectoryResolvedModuleNames.clear();
-            perDirectoryResolvedTypeReferenceDirectives.clear();
+            clearPerDirectoryResolutions();
         }
 
         function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
@@ -315,6 +320,33 @@ namespace ts {
             return endsWith(dirPath, "/node_modules");
         }
 
+        function isDirectoryAtleastAtLevelFromFSRoot(dirPath: Path, minLevels: number) {
+            for (let searchIndex = getRootLength(dirPath); minLevels > 0; minLevels--) {
+                searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
+                if (searchIndex === 0) {
+                    // Folder isnt at expected minimun levels
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        function canWatchDirectory(dirPath: Path) {
+            return isDirectoryAtleastAtLevelFromFSRoot(dirPath,
+                // When root is "/" do not watch directories like:
+                // "/", "/user", "/user/username", "/user/username/folderAtRoot"
+                // When root is "c:/" do not watch directories like:
+                // "c:/", "c:/folderAtRoot"
+                dirPath.charCodeAt(0) === CharacterCodes.slash ? 3 : 1);
+        }
+
+        function filterFSRootDirectoriesToWatch(watchPath: DirectoryOfFailedLookupWatch, dirPath: Path): DirectoryOfFailedLookupWatch {
+            if (!canWatchDirectory(dirPath)) {
+                watchPath.ignore = true;
+            }
+            return watchPath;
+        }
+
         function getDirectoryToWatchFailedLookupLocation(failedLookupLocation: string, failedLookupLocationPath: Path): DirectoryOfFailedLookupWatch {
             if (isInDirectoryPath(rootPath, failedLookupLocationPath)) {
                 return { dir: rootDir, dirPath: rootPath };
@@ -323,18 +355,15 @@ namespace ts {
             let dir = getDirectoryPath(getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory()));
             let dirPath = getDirectoryPath(failedLookupLocationPath);
 
-            // If the directory is node_modules use it to watch
-            if (isNodeModulesDirectory(dirPath)) {
-                return { dir, dirPath };
+            // If directory path contains node module, get the most parent node_modules directory for watching
+            while (stringContains(dirPath, "/node_modules/")) {
+                dir = getDirectoryPath(dir);
+                dirPath = getDirectoryPath(dirPath);
             }
 
-            // If directory path contains node module, get the node_modules directory for watching
-            if (dirPath.indexOf("/node_modules/") !== -1) {
-                while (!isNodeModulesDirectory(dirPath)) {
-                    dir = getDirectoryPath(dir);
-                    dirPath = getDirectoryPath(dirPath);
-                }
-                return { dir, dirPath };
+            // If the directory is node_modules use it to watch
+            if (isNodeModulesDirectory(dirPath)) {
+                return filterFSRootDirectoriesToWatch({ dir, dirPath }, getDirectoryPath(dirPath));
             }
 
             // Use some ancestor of the root directory
@@ -349,7 +378,7 @@ namespace ts {
                 }
             }
 
-            return { dir, dirPath };
+            return filterFSRootDirectoriesToWatch({ dir, dirPath }, dirPath);
         }
 
         function isPathWithDefaultFailedLookupExtension(path: Path) {
@@ -390,13 +419,15 @@ namespace ts {
                     const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
                     customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
                 }
-                const { dir, dirPath } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
-                const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
-                if (dirWatcher) {
-                    dirWatcher.refCount++;
-                }
-                else {
-                    directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath), refCount: 1 });
+                const { dir, dirPath, ignore } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
+                if (!ignore) {
+                    const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
+                    if (dirWatcher) {
+                        dirWatcher.refCount++;
+                    }
+                    else {
+                        directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath), refCount: 1 });
+                    }
                 }
             }
         }
@@ -421,10 +452,12 @@ namespace ts {
                         customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
                     }
                 }
-                const { dirPath } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
-                const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
-                // Do not close the watcher yet since it might be needed by other failed lookup locations.
-                dirWatcher.refCount--;
+                const { dirPath, ignore } = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
+                if (!ignore) {
+                    const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
+                    // Do not close the watcher yet since it might be needed by other failed lookup locations.
+                    dirWatcher.refCount--;
+                }
             }
         }
 
@@ -576,7 +609,8 @@ namespace ts {
             }
 
             // we need to assume the directories exist to ensure that we can get all the type root directories that get included
-            const typeRoots = getEffectiveTypeRoots(options, { directoryExists: returnTrue, getCurrentDirectory });
+            // But filter directories that are at root level to say directory doesnt exist, so that we arent watching them
+            const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
             if (typeRoots) {
                 mutateMap(
                     typeRootsWatches,
@@ -591,5 +625,16 @@ namespace ts {
                 closeTypeRootsWatch();
             }
         }
+
+        /**
+         * Use this function to return if directory exists to get type roots to watch
+         * If we return directory exists then only the paths will be added to type roots
+         * Hence return true for all directories except root directories which are filtered from watching
+         */
+        function directoryExistsForTypeRootWatch(nodeTypesDirectory: string) {
+            const dir = getDirectoryPath(getDirectoryPath(nodeTypesDirectory));
+            const dirPath = resolutionHost.toPath(dir);
+            return dirPath === rootPath || canWatchDirectory(dirPath);
+        }
     }
 }

src/compiler/scanner.ts

@@ -352,7 +352,7 @@ namespace ts {
     /**
      * We assume the first line starts at position 0 and 'position' is non-negative.
      */
-    export function computeLineAndCharacterOfPosition(lineStarts: ReadonlyArray<number>, position: number) {
+    export function computeLineAndCharacterOfPosition(lineStarts: ReadonlyArray<number>, position: number): LineAndCharacter {
         let lineNumber = binarySearch(lineStarts, position);
         if (lineNumber < 0) {
             // If the actual position was not found,

src/compiler/symbolWalker.ts

@@ -122,7 +122,7 @@ namespace ts {
                 }
                 forEach(signature.typeParameters, visitType);
 
-                for (const parameter of signature.parameters){
+                for (const parameter of signature.parameters) {
                     visitSymbol(parameter);
                 }
                 visitType(getRestTypeOfSignature(signature));

src/compiler/sys.ts

@@ -131,7 +131,7 @@ namespace ts {
             const _os = require("os");
             const _crypto = require("crypto");
 
-            const useNonPollingWatchers = process.env["TSC_NONPOLLING_WATCHER"];
+            const useNonPollingWatchers = process.env.TSC_NONPOLLING_WATCHER;
 
             function createWatchedFileSet() {
                 const dirWatchers = createMap<DirectoryWatcher>();
@@ -573,7 +573,7 @@ namespace ts {
 
         function recursiveCreateDirectory(directoryPath: string, sys: System) {
             const basePath = getDirectoryPath(directoryPath);
-            const shouldCreateParent = directoryPath !== basePath && !sys.directoryExists(basePath);
+            const shouldCreateParent = basePath !== "" && directoryPath !== basePath && !sys.directoryExists(basePath);
             if (shouldCreateParent) {
                 recursiveCreateDirectory(basePath, sys);
             }

src/compiler/transformers/es2015.ts

@@ -3676,7 +3676,8 @@ namespace ts {
             // Do not do this in the global scope, as any variable we currently generate could conflict with
             // variables from outside of the current compilation. In the future, we can revisit this behavior.
             if (isExternalModule(currentSourceFile)) {
-                const tempVar = createTempVariable(recordTaggedTemplateString);
+                const tempVar = createUniqueName("templateObject");
+                recordTaggedTemplateString(tempVar);
                 templateArguments[0] = createLogicalOr(
                     tempVar,
                     createAssignment(

src/compiler/transformers/es2017.ts

@@ -463,7 +463,7 @@ namespace ts {
         );
 
         // Mark this node as originally an async function
-        (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= EmitFlags.AsyncFunctionBody;
+        (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= EmitFlags.AsyncFunctionBody | EmitFlags.ReuseTempVariableScope;
 
         return createCall(
             getHelperName("__awaiter"),

src/compiler/transformers/generators.ts

@@ -1112,7 +1112,7 @@ namespace ts {
         }
 
         function visitCallExpression(node: CallExpression) {
-            if (forEach(node.arguments, containsYield)) {
+            if (!isImportCall(node) && forEach(node.arguments, containsYield)) {
                 // [source]
                 //      a.b(1, yield, 2);
                 //
@@ -1123,7 +1123,6 @@ namespace ts {
                 //  .yield resumeLabel
                 //  .mark resumeLabel
                 //      _b.apply(_a, _c.concat([%sent%, 2]));
-
                 const { target, thisArg } = createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, /*cacheIdentifiers*/ true);
                 return setOriginalNode(
                     createFunctionApply(

src/compiler/transformers/module/module.ts

@@ -21,7 +21,8 @@ namespace ts {
 
         const {
             startLexicalEnvironment,
-            endLexicalEnvironment
+            endLexicalEnvironment,
+            hoistVariableDeclaration
         } = context;
 
         const compilerOptions = context.getCompilerOptions();
@@ -519,18 +520,20 @@ namespace ts {
         }
 
         function visitImportCallExpression(node: ImportCall): Expression {
+            const argument = visitNode(firstOrUndefined(node.arguments), importCallExpressionVisitor);
+            const containsLexicalThis = !!(node.transformFlags & TransformFlags.ContainsLexicalThis);
             switch (compilerOptions.module) {
                 case ModuleKind.AMD:
-                    return transformImportCallExpressionAMD(node);
+                    return createImportCallExpressionAMD(argument, containsLexicalThis);
                 case ModuleKind.UMD:
-                    return transformImportCallExpressionUMD(node);
+                    return createImportCallExpressionUMD(argument, containsLexicalThis);
                 case ModuleKind.CommonJS:
                 default:
-                    return transformImportCallExpressionCommonJS(node);
+                    return createImportCallExpressionCommonJS(argument, containsLexicalThis);
             }
         }
 
-        function transformImportCallExpressionUMD(node: ImportCall): Expression {
+        function createImportCallExpressionUMD(arg: Expression | undefined, containsLexicalThis: boolean): Expression {
             // (function (factory) {
             //      ... (regular UMD)
             // }
@@ -545,14 +548,25 @@ namespace ts {
             //          : new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/
             // });
             needUMDDynamicImportHelper = true;
-            return createConditional(
-                /*condition*/ createIdentifier("__syncRequire"),
-                /*whenTrue*/ transformImportCallExpressionCommonJS(node),
-                /*whenFalse*/ transformImportCallExpressionAMD(node)
-            );
+            if (isSimpleCopiableExpression(arg)) {
+                const argClone = isGeneratedIdentifier(arg) ? arg : isStringLiteral(arg) ? createLiteral(arg) : setEmitFlags(setTextRange(getSynthesizedClone(arg), arg), EmitFlags.NoComments);
+                return createConditional(
+                    /*condition*/ createIdentifier("__syncRequire"),
+                    /*whenTrue*/ createImportCallExpressionCommonJS(arg, containsLexicalThis),
+                    /*whenFalse*/ createImportCallExpressionAMD(argClone, containsLexicalThis)
+                );
+            }
+            else {
+                const temp = createTempVariable(hoistVariableDeclaration);
+                return createComma(createAssignment(temp, arg), createConditional(
+                    /*condition*/ createIdentifier("__syncRequire"),
+                    /*whenTrue*/ createImportCallExpressionCommonJS(temp, containsLexicalThis),
+                    /*whenFalse*/ createImportCallExpressionAMD(temp, containsLexicalThis)
+                ));
+            }
         }
 
-        function transformImportCallExpressionAMD(node: ImportCall): Expression {
+        function createImportCallExpressionAMD(arg: Expression | undefined, containsLexicalThis: boolean): Expression {
             // improt("./blah")
             // emit as
             // define(["require", "exports", "blah"], function (require, exports) {
@@ -561,46 +575,89 @@ namespace ts {
             // });
             const resolve = createUniqueName("resolve");
             const reject = createUniqueName("reject");
-            return createNew(
-                createIdentifier("Promise"),
-                /*typeArguments*/ undefined,
-                [createFunctionExpression(
+            const parameters = [
+                createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve),
+                createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject)
+            ];
+            const body = createBlock([
+                createStatement(
+                    createCall(
+                        createIdentifier("require"),
+                        /*typeArguments*/ undefined,
+                        [createArrayLiteral([arg || createOmittedExpression()]), resolve, reject]
+                    )
+                )
+            ]);
+
+            let func: FunctionExpression | ArrowFunction;
+            if (languageVersion >= ScriptTarget.ES2015) {
+                func = createArrowFunction(
+                    /*modifiers*/ undefined,
+                    /*typeParameters*/ undefined,
+                    parameters,
+                    /*type*/ undefined,
+                    /*equalsGreaterThanToken*/ undefined,
+                    body);
+            }
+            else {
+                func = createFunctionExpression(
                     /*modifiers*/ undefined,
                     /*asteriskToken*/ undefined,
                     /*name*/ undefined,
                     /*typeParameters*/ undefined,
-                    [createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve),
-                     createParameter(/*decorator*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject)],
+                    parameters,
                     /*type*/ undefined,
-                    createBlock([createStatement(
-                        createCall(
-                            createIdentifier("require"),
-                            /*typeArguments*/ undefined,
-                            [createArrayLiteral([firstOrUndefined(node.arguments) || createOmittedExpression()]), resolve, reject]
-                        ))])
-            )]);
+                    body);
+
+                // if there is a lexical 'this' in the import call arguments, ensure we indicate
+                // that this new function expression indicates it captures 'this' so that the
+                // es2015 transformer will properly substitute 'this' with '_this'.
+                if (containsLexicalThis) {
+                    setEmitFlags(func, EmitFlags.CapturesThis);
+                }
+            }
+
+            return createNew(createIdentifier("Promise"), /*typeArguments*/ undefined, [func]);
         }
 
-    function transformImportCallExpressionCommonJS(node: ImportCall): Expression {
+        function createImportCallExpressionCommonJS(arg: Expression | undefined, containsLexicalThis: boolean): Expression {
             // import("./blah")
             // emit as
             // Promise.resolve().then(function () { return require(x); }) /*CommonJs Require*/
             // We have to wrap require in then callback so that require is done in asynchronously
             // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately
-            return createCall(
-                createPropertyAccess(
-                    createCall(createPropertyAccess(createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []),
-                    "then"),
-                /*typeArguments*/ undefined,
-                [createFunctionExpression(
+            const promiseResolveCall = createCall(createPropertyAccess(createIdentifier("Promise"), "resolve"), /*typeArguments*/ undefined, /*argumentsArray*/ []);
+            const requireCall = createCall(createIdentifier("require"), /*typeArguments*/ undefined, arg ? [arg] : []);
+
+            let func: FunctionExpression | ArrowFunction;
+            if (languageVersion >= ScriptTarget.ES2015) {
+                func = createArrowFunction(
+                    /*modifiers*/ undefined,
+                    /*typeParameters*/ undefined,
+                    /*parameters*/ [],
+                    /*type*/ undefined,
+                    /*equalsGreaterThanToken*/ undefined,
+                    requireCall);
+            }
+            else {
+                func = createFunctionExpression(
                     /*modifiers*/ undefined,
                     /*asteriskToken*/ undefined,
                     /*name*/ undefined,
                     /*typeParameters*/ undefined,
-                    /*parameters*/ undefined,
+                    /*parameters*/ [],
                     /*type*/ undefined,
-                    createBlock([createReturn(createCall(createIdentifier("require"), /*typeArguments*/ undefined, node.arguments))])
-                )]);
+                    createBlock([createReturn(requireCall)]));
+
+                // if there is a lexical 'this' in the import call arguments, ensure we indicate
+                // that this new function expression indicates it captures 'this' so that the
+                // es2015 transformer will properly substitute 'this' with '_this'.
+                if (containsLexicalThis) {
+                    setEmitFlags(func, EmitFlags.CapturesThis);
+                }
+            }
+
+            return createCall(createPropertyAccess(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]);
         }
 
         /**
@@ -861,10 +918,10 @@ namespace ts {
             if (original && hasAssociatedEndOfDeclarationMarker(original)) {
                 // Defer exports until we encounter an EndOfDeclarationMarker node
                 const id = getOriginalNodeId(node);
-                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
+                deferredExports[id] = appendExportStatement(deferredExports[id], createIdentifier("default"), visitNode(node.expression, importCallExpressionVisitor), /*location*/ node, /*allowComments*/ true);
             }
             else {
-                statements = appendExportStatement(statements, createIdentifier("default"), node.expression, /*location*/ node, /*allowComments*/ true);
+                statements = appendExportStatement(statements, createIdentifier("default"), visitNode(node.expression, importCallExpressionVisitor), /*location*/ node, /*allowComments*/ true);
             }
 
             return singleOrMany(statements);

src/compiler/transformers/module/system.ts

@@ -826,7 +826,7 @@ namespace ts {
                     /*needsValue*/ false,
                     createAssignment
                 )
-                : createAssignment(node.name, visitNode(node.initializer, destructuringAndImportCallVisitor, isExpression));
+                : node.initializer ? createAssignment(node.name, visitNode(node.initializer, destructuringAndImportCallVisitor, isExpression)) : node.name;
         }
 
         /**
@@ -1296,6 +1296,9 @@ namespace ts {
                 let expressions: Expression[];
                 for (const variable of node.declarations) {
                     expressions = append(expressions, transformInitializedVariable(variable, /*isExportedDeclaration*/ false));
+                    if (!variable.initializer) {
+                        hoistBindingElement(variable);
+                    }
                 }
 
                 return expressions ? inlineExpressions(expressions) : createOmittedExpression();
@@ -1495,7 +1498,7 @@ namespace ts {
                     createIdentifier("import")
                 ),
                 /*typeArguments*/ undefined,
-                node.arguments
+                some(node.arguments) ? [visitNode(node.arguments[0], destructuringAndImportCallVisitor)] : []
             );
         }
 

src/compiler/transformers/ts.ts

@@ -26,7 +26,7 @@ namespace ts {
         IsExportOfNamespace = 1 << 3,
         IsNamedExternalExport = 1 << 4,
         IsDefaultExternalExport = 1 << 5,
-        HasExtendsClause = 1 << 6,
+        IsDerivedClass = 1 << 6,
         UseImmediatelyInvokedFunctionExpression = 1 << 7,
 
         HasAnyDecorators = HasConstructorDecorators | HasMemberDecorators,
@@ -45,6 +45,7 @@ namespace ts {
 
         const resolver = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
+        const strictNullChecks = typeof compilerOptions.strictNullChecks === "undefined" ? compilerOptions.strict : compilerOptions.strictNullChecks;
         const languageVersion = getEmitScriptTarget(compilerOptions);
         const moduleKind = getEmitModuleKind(compilerOptions);
 
@@ -553,7 +554,8 @@ namespace ts {
         function getClassFacts(node: ClassDeclaration, staticProperties: ReadonlyArray<PropertyDeclaration>) {
             let facts = ClassFacts.None;
             if (some(staticProperties)) facts |= ClassFacts.HasStaticInitializedProperties;
-            if (getClassExtendsHeritageClauseElement(node)) facts |= ClassFacts.HasExtendsClause;
+            const extendsClauseElement = getClassExtendsHeritageClauseElement(node);
+            if (extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== SyntaxKind.NullKeyword) facts |= ClassFacts.IsDerivedClass;
             if (shouldEmitDecorateCallForClass(node)) facts |= ClassFacts.HasConstructorDecorators;
             if (childIsDecorated(node)) facts |= ClassFacts.HasMemberDecorators;
             if (isExportOfNamespace(node)) facts |= ClassFacts.IsExportOfNamespace;
@@ -699,7 +701,7 @@ namespace ts {
                 name,
                 /*typeParameters*/ undefined,
                 visitNodes(node.heritageClauses, visitor, isHeritageClause),
-                transformClassMembers(node, (facts & ClassFacts.HasExtendsClause) !== 0)
+                transformClassMembers(node, (facts & ClassFacts.IsDerivedClass) !== 0)
             );
 
             // To better align with the old emitter, we should not emit a trailing source map
@@ -814,7 +816,7 @@ namespace ts {
             //      ${members}
             //  }
             const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);
-            const members = transformClassMembers(node, (facts & ClassFacts.HasExtendsClause) !== 0);
+            const members = transformClassMembers(node, (facts & ClassFacts.IsDerivedClass) !== 0);
             const classExpression = createClassExpression(/*modifiers*/ undefined, name, /*typeParameters*/ undefined, heritageClauses, members);
             setOriginalNode(classExpression, node);
             setTextRange(classExpression, location);
@@ -887,11 +889,11 @@ namespace ts {
          * Transforms the members of a class.
          *
          * @param node The current class.
-         * @param hasExtendsClause A value indicating whether the class has an extends clause.
+         * @param isDerivedClass A value indicating whether the class has an extends clause that does not extend 'null'.
          */
-        function transformClassMembers(node: ClassDeclaration | ClassExpression, hasExtendsClause: boolean) {
+        function transformClassMembers(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean) {
             const members: ClassElement[] = [];
-            const constructor = transformConstructor(node, hasExtendsClause);
+            const constructor = transformConstructor(node, isDerivedClass);
             if (constructor) {
                 members.push(constructor);
             }
@@ -904,9 +906,9 @@ namespace ts {
          * Transforms (or creates) a constructor for a class.
          *
          * @param node The current class.
-         * @param hasExtendsClause A value indicating whether the class has an extends clause.
+         * @param isDerivedClass A value indicating whether the class has an extends clause that does not extend 'null'.
          */
-        function transformConstructor(node: ClassDeclaration | ClassExpression, hasExtendsClause: boolean) {
+        function transformConstructor(node: ClassDeclaration | ClassExpression, isDerivedClass: boolean) {
             // Check if we have property assignment inside class declaration.
             // If there is a property assignment, we need to emit constructor whether users define it or not
             // If there is no property assignment, we can omit constructor if users do not define it
@@ -921,7 +923,7 @@ namespace ts {
             }
 
             const parameters = transformConstructorParameters(constructor);
-            const body = transformConstructorBody(node, constructor, hasExtendsClause);
+            const body = transformConstructorBody(node, constructor, isDerivedClass);
 
             //  constructor(${parameters}) {
             //      ${body}
@@ -947,7 +949,6 @@ namespace ts {
          * parameter property assignments or instance property initializers.
          *
          * @param constructor The constructor declaration.
-         * @param hasExtendsClause A value indicating whether the class has an extends clause.
          */
         function transformConstructorParameters(constructor: ConstructorDeclaration) {
             // The ES2015 spec specifies in 14.5.14. Runtime Semantics: ClassDefinitionEvaluation:
@@ -975,9 +976,9 @@ namespace ts {
          *
          * @param node The current class.
          * @param constructor The current class constructor.
-         * @param hasExtendsClause A value indicating whether the class has an extends clause.
+         * @param isDerivedClass A value indicating whether the class has an extends clause that does not extend 'null'.
          */
-        function transformConstructorBody(node: ClassExpression | ClassDeclaration, constructor: ConstructorDeclaration, hasExtendsClause: boolean) {
+        function transformConstructorBody(node: ClassExpression | ClassDeclaration, constructor: ConstructorDeclaration, isDerivedClass: boolean) {
             let statements: Statement[] = [];
             let indexOfFirstStatement = 0;
 
@@ -1001,7 +1002,7 @@ namespace ts {
                 const propertyAssignments = getParametersWithPropertyAssignments(constructor);
                 addRange(statements, map(propertyAssignments, transformParameterWithPropertyAssignment));
             }
-            else if (hasExtendsClause) {
+            else if (isDerivedClass) {
                 // Add a synthetic `super` call:
                 //
                 //  super(...arguments);
@@ -1869,7 +1870,16 @@ namespace ts {
             // Note when updating logic here also update getEntityNameForDecoratorMetadata
             // so that aliases can be marked as referenced
             let serializedUnion: SerializedTypeNode;
-            for (const typeNode of node.types) {
+            for (let typeNode of node.types) {
+                while (typeNode.kind === SyntaxKind.ParenthesizedType) {
+                    typeNode = (typeNode as ParenthesizedTypeNode).type; // Skip parens if need be
+                }
+                if (typeNode.kind === SyntaxKind.NeverKeyword) {
+                    continue; // Always elide `never` from the union/intersection if possible
+                }
+                if (!strictNullChecks && (typeNode.kind === SyntaxKind.NullKeyword || typeNode.kind === SyntaxKind.UndefinedKeyword)) {
+                    continue; // Elide null and undefined from unions for metadata, just like what we did prior to the implementation of strict null checks
+                }
                 const serializedIndividual = serializeTypeNode(typeNode);
 
                 if (isIdentifier(serializedIndividual) && serializedIndividual.escapedText === "Object") {
@@ -1893,7 +1903,7 @@ namespace ts {
             }
 
             // If we were able to find common type, use it
-            return serializedUnion;
+            return serializedUnion || createVoidZero(); // Fallback is only hit if all union constituients are null/undefined/never
         }
 
         /**

src/compiler/transformers/utilities.ts

@@ -178,4 +178,17 @@ namespace ts {
         }
         return values;
     }
+
+    /**
+     * Used in the module transformer to check if an expression is reasonably without sideeffect,
+     *  and thus better to copy into multiple places rather than to cache in a temporary variable
+     *  - this is mostly subjective beyond the requirement that the expression not be sideeffecting
+     */
+    export function isSimpleCopiableExpression(expression: Expression) {
+        return expression.kind === SyntaxKind.StringLiteral ||
+            expression.kind === SyntaxKind.NumericLiteral ||
+            expression.kind === SyntaxKind.NoSubstitutionTemplateLiteral ||
+            isKeyword(expression.kind) ||
+            isIdentifier(expression);
+    }
 }

src/compiler/types.ts

@@ -1073,6 +1073,7 @@ namespace ts {
     export interface StringLiteral extends LiteralExpression {
         kind: SyntaxKind.StringLiteral;
         /* @internal */ textSourceNode?: Identifier | StringLiteral | NumericLiteral; // Allows a StringLiteral to get its text from another node (used by transforms).
+        /** Note: this is only set when synthesizing a node, not during parsing. */
         /* @internal */ singleQuote?: boolean;
     }
 
@@ -2177,6 +2178,10 @@ namespace ts {
         kind: SyntaxKind.JSDocTag;
     }
 
+    /**
+     * Note that `@extends` is a synonym of `@augments`.
+     * Both tags are represented by this interface.
+     */
     export interface JSDocAugmentsTag extends JSDocTag {
         kind: SyntaxKind.JSDocAugmentsTag;
         class: ExpressionWithTypeArguments & { expression: Identifier | PropertyAccessEntityNameExpression };
@@ -2212,7 +2217,7 @@ namespace ts {
     export interface JSDocPropertyLikeTag extends JSDocTag, Declaration {
         parent: JSDoc;
         name: EntityName;
-        typeExpression: JSDocTypeExpression;
+        typeExpression?: JSDocTypeExpression;
         /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */
         isNameFirst: boolean;
         isBracketed: boolean;
@@ -2543,8 +2548,6 @@ namespace ts {
         /* @internal */ sourceFileToPackageName: Map<string>;
         /** Set of all source files that some other source file redirects to. */
         /* @internal */ redirectTargetsSet: Map<true>;
-        /** Returns true when file in the program had invalidated resolution at the time of program creation. */
-        /* @internal */ hasInvalidatedResolution: HasInvalidatedResolution;
     }
 
     /* @internal */
@@ -2667,6 +2670,10 @@ namespace ts {
         signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+        /**
+         * @deprecated Use the createX factory functions or XToY typechecker methods and `createPrinter` or the `xToString` methods instead
+         * This will be removed in a future version.
+         */
         getSymbolDisplayBuilder(): SymbolDisplayBuilder;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfType(type: Type): Symbol[];
@@ -2707,6 +2714,24 @@ namespace ts {
         getSuggestionForNonexistentSymbol(location: Node, name: string, meaning: SymbolFlags): string | undefined;
         /* @internal */ getBaseConstraintOfType(type: Type): Type | undefined;
 
+        /* @internal */ getAnyType(): Type;
+        /* @internal */ getStringType(): Type;
+        /* @internal */ getNumberType(): Type;
+        /* @internal */ getBooleanType(): Type;
+        /* @internal */ getVoidType(): Type;
+        /* @internal */ getUndefinedType(): Type;
+        /* @internal */ getNullType(): Type;
+        /* @internal */ getESSymbolType(): Type;
+        /* @internal */ getNeverType(): Type;
+        /* @internal */ getUnionType(types: Type[], subtypeReduction?: boolean): Type;
+        /* @internal */ createArrayType(elementType: Type): Type;
+        /* @internal */ createPromiseType(type: Type): Type;
+
+        /* @internal */ createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo): Type;
+        /* @internal */ createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[], thisParameter: Symbol | undefined, parameters: Symbol[], resolvedReturnType: Type, typePredicate: TypePredicate, minArgumentCount: number, hasRestParameter: boolean, hasLiteralTypes: boolean): Signature;
+        /* @internal */ createSymbol(flags: SymbolFlags, name: __String): TransientSymbol;
+        /* @internal */ createIndexInfo(type: Type, isReadonly: boolean, declaration?: SignatureDeclaration): IndexInfo;
+        /* @internal */ isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         /* @internal */ tryFindAmbientModuleWithoutAugmentations(moduleName: string): Symbol | undefined;
 
         /* @internal */ getSymbolWalker(accept?: (symbol: Symbol) => boolean): SymbolWalker;
@@ -3641,6 +3666,7 @@ namespace ts {
     export interface JsFileExtensionInfo {
         extension: string;
         isMixedContent: boolean;
+        scriptKind?: ScriptKind;
     }
 
     export interface DiagnosticMessage {
@@ -3825,9 +3851,10 @@ namespace ts {
     }
 
     export interface LineAndCharacter {
+        /** 0-based. */
         line: number;
         /*
-         * This value denotes the character position in line and is different from the 'column' because of tab characters.
+         * 0-based. This value denotes the character position in line and is different from the 'column' because of tab characters.
          */
         character: number;
     }

src/compiler/utilities.ts

@@ -520,6 +520,17 @@ namespace ts {
         }
     }
 
+    /* @internal */
+    export function isAnyImportSyntax(node: Node): node is AnyImportSyntax {
+        switch (node.kind) {
+            case SyntaxKind.ImportDeclaration:
+            case SyntaxKind.ImportEqualsDeclaration:
+                return true;
+            default:
+                return false;
+        }
+    }
+
     // Gets the nearest enclosing block scope container that has the provided node
     // as a descendant, that is not the provided node.
     export function getEnclosingBlockScopeContainer(node: Node): Node {
@@ -571,14 +582,14 @@ namespace ts {
         }
     }
 
-    export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): Diagnostic {
+    export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
         const sourceFile = getSourceFileOfNode(node);
-        return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2);
+        return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
     }
 
-    export function createDiagnosticForNodeInSourceFile(sourceFile: SourceFile, node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number): Diagnostic {
+    export function createDiagnosticForNodeInSourceFile(sourceFile: SourceFile, node: Node, message: DiagnosticMessage, arg0?: string | number, arg1?: string | number, arg2?: string | number, arg3?: string | number): Diagnostic {
         const span = getErrorSpanForNode(sourceFile, node);
-        return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2);
+        return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
     }
 
     export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain): Diagnostic {
@@ -1366,6 +1377,14 @@ namespace ts {
         return node && !!(node.flags & NodeFlags.JSDoc);
     }
 
+    export function isJSDocIndexSignature(node: TypeReferenceNode | ExpressionWithTypeArguments) {
+        return isTypeReferenceNode(node) &&
+            isIdentifier(node.typeName) &&
+            node.typeName.escapedText === "Object" &&
+            node.typeArguments && node.typeArguments.length === 2 &&
+            (node.typeArguments[0].kind === SyntaxKind.StringKeyword || node.typeArguments[0].kind === SyntaxKind.NumberKeyword);
+    }
+
     /**
      * Returns true if the node is a CallExpression to the identifier 'require' with
      * exactly one argument (of the form 'require("name")').
@@ -1392,6 +1411,10 @@ namespace ts {
         return charCode === CharacterCodes.singleQuote || charCode === CharacterCodes.doubleQuote;
     }
 
+    export function isStringDoubleQuoted(string: StringLiteral, sourceFile: SourceFile): boolean {
+        return getSourceTextOfNodeFromSourceFile(sourceFile, string).charCodeAt(0) === CharacterCodes.doubleQuote;
+    }
+
     /**
      * Returns true if the node is a variable declaration whose initializer is a function expression.
      * This function does not test if the node is in a JavaScript file or not.
@@ -1532,6 +1555,34 @@ namespace ts {
         return getJSDocCommentsAndTags(node);
     }
 
+    export function getSourceOfAssignment(node: Node): Node {
+        return isExpressionStatement(node) &&
+            node.expression && isBinaryExpression(node.expression) &&
+            node.expression.operatorToken.kind === SyntaxKind.EqualsToken &&
+            node.expression.right;
+    }
+
+    export function getSingleInitializerOfVariableStatement(node: Node, child?: Node): Node {
+        return isVariableStatement(node) &&
+            node.declarationList.declarations.length > 0 &&
+            (!child || node.declarationList.declarations[0].initializer === child) &&
+            node.declarationList.declarations[0].initializer;
+    }
+
+    export function getSingleVariableOfVariableStatement(node: Node, child?: Node): Node {
+        return isVariableStatement(node) &&
+            node.declarationList.declarations.length > 0 &&
+            (!child || node.declarationList.declarations[0] === child) &&
+            node.declarationList.declarations[0];
+    }
+
+    export function getNestedModuleDeclaration(node: Node): Node {
+        return node.kind === SyntaxKind.ModuleDeclaration &&
+            (node as ModuleDeclaration).body &&
+            (node as ModuleDeclaration).body.kind === SyntaxKind.ModuleDeclaration &&
+            (node as ModuleDeclaration).body;
+    }
+
     export function getJSDocCommentsAndTags(node: Node): (JSDoc | JSDocTag)[] {
         let result: (JSDoc | JSDocTag)[] | undefined;
         getJSDocCommentsAndTagsWorker(node);
@@ -1545,35 +1596,15 @@ namespace ts {
             //   * @returns {number}
             //   */
             // var x = function(name) { return name.length; }
-            const isInitializerOfVariableDeclarationInStatement =
-                isVariableLike(parent) &&
-                parent.initializer === node &&
-                parent.parent.parent.kind === SyntaxKind.VariableStatement;
-            const isVariableOfVariableDeclarationStatement = isVariableLike(node) &&
-                parent.parent.kind === SyntaxKind.VariableStatement;
-            const variableStatementNode =
-                isInitializerOfVariableDeclarationInStatement ? parent.parent.parent :
-                    isVariableOfVariableDeclarationStatement ? parent.parent :
-                        undefined;
-            if (variableStatementNode) {
-                getJSDocCommentsAndTagsWorker(variableStatementNode);
+            if (parent && (parent.kind === SyntaxKind.PropertyAssignment || getNestedModuleDeclaration(parent))) {
+                getJSDocCommentsAndTagsWorker(parent);
             }
-
-            // Also recognize when the node is the RHS of an assignment expression
-            const isSourceOfAssignmentExpressionStatement =
-                parent && parent.parent &&
-                parent.kind === SyntaxKind.BinaryExpression &&
-                (parent as BinaryExpression).operatorToken.kind === SyntaxKind.EqualsToken &&
-                parent.parent.kind === SyntaxKind.ExpressionStatement;
-            if (isSourceOfAssignmentExpressionStatement) {
+            if (parent && parent.parent &&
+                (getSingleVariableOfVariableStatement(parent.parent, node) || getSourceOfAssignment(parent.parent))) {
                 getJSDocCommentsAndTagsWorker(parent.parent);
             }
-
-            const isModuleDeclaration = node.kind === SyntaxKind.ModuleDeclaration &&
-                parent && parent.kind === SyntaxKind.ModuleDeclaration;
-            const isPropertyAssignmentExpression = parent && parent.kind === SyntaxKind.PropertyAssignment;
-            if (isModuleDeclaration || isPropertyAssignmentExpression) {
-                getJSDocCommentsAndTagsWorker(parent);
+            if (parent && parent.parent && parent.parent.parent && getSingleInitializerOfVariableStatement(parent.parent.parent, node)) {
+                getJSDocCommentsAndTagsWorker(parent.parent.parent);
             }
 
             // Pull parameter comments from declaring function as well
@@ -1600,13 +1631,16 @@ namespace ts {
             return undefined;
         }
         const name = node.name.escapedText;
-        const func = getJSDocHost(node);
-        if (!isFunctionLike(func)) {
-            return undefined;
+        const host = getJSDocHost(node);
+        const decl = getSourceOfAssignment(host) ||
+            getSingleInitializerOfVariableStatement(host) ||
+            getSingleVariableOfVariableStatement(host) ||
+            getNestedModuleDeclaration(host) ||
+            host;
+        if (decl && isFunctionLike(decl)) {
+            const parameter = find(decl.parameters, p => p.name.kind === SyntaxKind.Identifier && p.name.escapedText === name);
+            return parameter && parameter.symbol;
         }
-        const parameter = find(func.parameters, p =>
-            p.name.kind === SyntaxKind.Identifier && p.name.escapedText === name);
-        return parameter && parameter.symbol;
     }
 
     export function getJSDocHost(node: JSDocTag): HasJSDoc {
@@ -1621,26 +1655,12 @@ namespace ts {
     }
 
     export function hasRestParameter(s: SignatureDeclaration): boolean {
-        return isRestParameter(lastOrUndefined(s.parameters));
+        const last = lastOrUndefined(s.parameters);
+        return last && isRestParameter(last);
     }
 
-    export function hasDeclaredRestParameter(s: SignatureDeclaration): boolean {
-        return isDeclaredRestParam(lastOrUndefined(s.parameters));
-    }
-
-    export function isRestParameter(node: ParameterDeclaration) {
-        if (isInJavaScriptFile(node)) {
-            if (node.type && node.type.kind === SyntaxKind.JSDocVariadicType ||
-                forEach(getJSDocParameterTags(node),
-                    t => t.typeExpression && t.typeExpression.type.kind === SyntaxKind.JSDocVariadicType)) {
-                return true;
-            }
-        }
-        return isDeclaredRestParam(node);
-    }
-
-    export function isDeclaredRestParam(node: ParameterDeclaration) {
-        return node && node.dotDotDotToken !== undefined;
+    export function isRestParameter(node: ParameterDeclaration): boolean {
+        return node.dotDotDotToken !== undefined;
     }
 
     export const enum AssignmentKind {
@@ -2746,11 +2766,11 @@ namespace ts {
      * Gets the effective type annotation of a variable, parameter, or property. If the node was
      * parsed in a JavaScript file, gets the type annotation from JSDoc.
      */
-    export function getEffectiveTypeAnnotationNode(node: VariableLikeDeclaration): TypeNode | undefined {
+    export function getEffectiveTypeAnnotationNode(node: VariableLikeDeclaration, checkJSDoc?: boolean): TypeNode | undefined {
         if (node.type) {
             return node.type;
         }
-        if (isInJavaScriptFile(node)) {
+        if (checkJSDoc || isInJavaScriptFile(node)) {
             return getJSDocType(node);
         }
     }
@@ -2759,11 +2779,11 @@ namespace ts {
      * Gets the effective return type annotation of a signature. If the node was parsed in a
      * JavaScript file, gets the return type annotation from JSDoc.
      */
-    export function getEffectiveReturnTypeNode(node: SignatureDeclaration): TypeNode | undefined {
+    export function getEffectiveReturnTypeNode(node: SignatureDeclaration, checkJSDoc?: boolean): TypeNode | undefined {
         if (node.type) {
             return node.type;
         }
-        if (isInJavaScriptFile(node)) {
+        if (checkJSDoc || isInJavaScriptFile(node)) {
             return getJSDocReturnType(node);
         }
     }
@@ -2772,11 +2792,11 @@ namespace ts {
      * Gets the effective type parameters. If the node was parsed in a
      * JavaScript file, gets the type parameters from the `@template` tag from JSDoc.
      */
-    export function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters): ReadonlyArray<TypeParameterDeclaration> {
+    export function getEffectiveTypeParameterDeclarations(node: DeclarationWithTypeParameters, checkJSDoc?: boolean): ReadonlyArray<TypeParameterDeclaration> {
         if (node.typeParameters) {
             return node.typeParameters;
         }
-        if (isInJavaScriptFile(node)) {
+        if (checkJSDoc || isInJavaScriptFile(node)) {
             const templateTag = getJSDocTemplateTag(node);
             return templateTag && templateTag.typeParameters;
         }
@@ -2786,9 +2806,9 @@ namespace ts {
      * Gets the effective type annotation of the value parameter of a set accessor. If the node
      * was parsed in a JavaScript file, gets the type annotation from JSDoc.
      */
-    export function getEffectiveSetAccessorTypeAnnotationNode(node: SetAccessorDeclaration): TypeNode {
+    export function getEffectiveSetAccessorTypeAnnotationNode(node: SetAccessorDeclaration, checkJSDoc?: boolean): TypeNode {
         const parameter = getSetAccessorValueParameter(node);
-        return parameter && getEffectiveTypeAnnotationNode(parameter);
+        return parameter && getEffectiveTypeAnnotationNode(parameter, checkJSDoc);
     }
 
     export function emitNewLineBeforeLeadingComments(lineMap: ReadonlyArray<number>, writer: EmitTextWriter, node: TextRange, leadingComments: ReadonlyArray<CommentRange>) {
@@ -3238,7 +3258,7 @@ namespace ts {
 
     const carriageReturnLineFeed = "\r\n";
     const lineFeed = "\n";
-    export function getNewLineCharacter(options: CompilerOptions | PrinterOptions, system?: System): string {
+    export function getNewLineCharacter(options: CompilerOptions | PrinterOptions, system?: { newLine: string }): string {
         switch (options.newLine) {
             case NewLineKind.CarriageReturnLineFeed:
                 return carriageReturnLineFeed;
@@ -4152,27 +4172,35 @@ namespace ts {
         if (!declaration) {
             return undefined;
         }
-        if (isJSDocPropertyLikeTag(declaration) && declaration.name.kind === SyntaxKind.QualifiedName) {
-            return declaration.name.right;
-        }
-        if (declaration.kind === SyntaxKind.BinaryExpression) {
-            const expr = declaration as BinaryExpression;
-            switch (getSpecialPropertyAssignmentKind(expr)) {
-                case SpecialPropertyAssignmentKind.ExportsProperty:
-                case SpecialPropertyAssignmentKind.ThisProperty:
-                case SpecialPropertyAssignmentKind.Property:
-                case SpecialPropertyAssignmentKind.PrototypeProperty:
-                    return (expr.left as PropertyAccessExpression).name;
-                default:
-                    return undefined;
+        switch (declaration.kind) {
+            case SyntaxKind.JSDocPropertyTag:
+            case SyntaxKind.JSDocParameterTag: {
+                const { name } = declaration as JSDocPropertyLikeTag;
+                if (name.kind === SyntaxKind.QualifiedName) {
+                    return name.right;
+                }
+                break;
+            }
+            case SyntaxKind.BinaryExpression: {
+                const expr = declaration as BinaryExpression;
+                switch (getSpecialPropertyAssignmentKind(expr)) {
+                    case SpecialPropertyAssignmentKind.ExportsProperty:
+                    case SpecialPropertyAssignmentKind.ThisProperty:
+                    case SpecialPropertyAssignmentKind.Property:
+                    case SpecialPropertyAssignmentKind.PrototypeProperty:
+                        return (expr.left as PropertyAccessExpression).name;
+                    default:
+                        return undefined;
+                }
+            }
+            case SyntaxKind.JSDocTypedefTag:
+                return getNameOfJSDocTypedef(declaration as JSDocTypedefTag);
+            case SyntaxKind.ExportAssignment: {
+                const { expression } = declaration as ExportAssignment;
+                return isIdentifier(expression) ? expression : undefined;
             }
         }
-        else if (declaration.kind === SyntaxKind.JSDocTypedefTag) {
-            return getNameOfJSDocTypedef(declaration as JSDocTypedefTag);
-        }
-        else {
-            return (declaration as NamedDeclaration).name;
-        }
+        return (declaration as NamedDeclaration).name;
     }
 
     /**
@@ -4287,6 +4315,12 @@ namespace ts {
         return find(tags, doc => doc.kind === kind);
     }
 
+    /** Gets all JSDoc tags of a specified kind, or undefined if not present. */
+    export function getAllJSDocTagsOfKind(node: Node, kind: SyntaxKind): ReadonlyArray<JSDocTag> | undefined {
+        const tags = getJSDocTags(node);
+        return filter(tags, doc => doc.kind === kind);
+    }
+
 }
 
 // Simple node tests of the form `node.kind === SyntaxKind.Foo`.
@@ -5170,7 +5204,14 @@ namespace ts {
             || kind === SyntaxKind.UndefinedKeyword
             || kind === SyntaxKind.NullKeyword
             || kind === SyntaxKind.NeverKeyword
-            || kind === SyntaxKind.ExpressionWithTypeArguments;
+            || kind === SyntaxKind.ExpressionWithTypeArguments
+            || kind === SyntaxKind.JSDocAllType
+            || kind === SyntaxKind.JSDocUnknownType
+            || kind === SyntaxKind.JSDocNullableType
+            || kind === SyntaxKind.JSDocNonNullableType
+            || kind === SyntaxKind.JSDocOptionalType
+            || kind === SyntaxKind.JSDocFunctionType
+            || kind === SyntaxKind.JSDocVariadicType;
     }
 
     /**
@@ -5689,6 +5730,14 @@ namespace ts {
         return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;
     }
 
+    export function isSetAccessor(node: Node): node is SetAccessorDeclaration {
+        return node.kind === SyntaxKind.SetAccessor;
+    }
+
+    export function isGetAccessor(node: Node): node is GetAccessorDeclaration {
+        return node.kind === SyntaxKind.GetAccessor;
+    }
+
     /** True if has jsdoc nodes attached to it. */
     /* @internal */
     export function hasJSDocNodes(node: Node): node is HasJSDoc {

src/compiler/watch.ts

@@ -144,13 +144,14 @@ namespace ts {
 
         function compileWatchedProgram(host: DirectoryStructureHost, program: Program, builder: Builder) {
             // First get and report any syntactic errors.
-            let diagnostics = program.getSyntacticDiagnostics().slice();
+            const diagnostics = program.getSyntacticDiagnostics().slice();
             let reportSemanticDiagnostics = false;
 
             // If we didn't have any syntactic errors, then also try getting the global and
             // semantic errors.
             if (diagnostics.length === 0) {
-                diagnostics = program.getOptionsDiagnostics().concat(program.getGlobalDiagnostics());
+                addRange(diagnostics, program.getOptionsDiagnostics());
+                addRange(diagnostics, program.getGlobalDiagnostics());
 
                 if (diagnostics.length === 0) {
                     reportSemanticDiagnostics = true;
@@ -162,7 +163,7 @@ namespace ts {
             let sourceMaps: SourceMapData[];
             let emitSkipped: boolean;
 
-            const result = builder.emitChangedFiles(program);
+            const result = builder.emitChangedFiles(program, writeFile);
             if (result.length === 0) {
                 emitSkipped = true;
             }
@@ -171,14 +172,13 @@ namespace ts {
                     if (emitOutput.emitSkipped) {
                         emitSkipped = true;
                     }
-                    diagnostics = concatenate(diagnostics, emitOutput.diagnostics);
+                    addRange(diagnostics, emitOutput.diagnostics);
                     sourceMaps = concatenate(sourceMaps, emitOutput.sourceMaps);
-                    writeOutputFiles(emitOutput.outputFiles);
                 }
             }
 
             if (reportSemanticDiagnostics) {
-                diagnostics = diagnostics.concat(builder.getSemanticDiagnostics(program));
+                addRange(diagnostics, builder.getSemanticDiagnostics(program));
             }
             return handleEmitOutputAndReportErrors(host, program, emittedFiles, emitSkipped,
                 diagnostics, reportDiagnostic);
@@ -191,31 +191,23 @@ namespace ts {
                 }
             }
 
-            function writeFile(fileName: string, data: string, writeByteOrderMark: boolean) {
+            function writeFile(fileName: string, text: string, writeByteOrderMark: boolean, onError: (message: string) => void) {
                 try {
                     performance.mark("beforeIOWrite");
                     ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));
 
-                    host.writeFile(fileName, data, writeByteOrderMark);
+                    host.writeFile(fileName, text, writeByteOrderMark);
 
                     performance.mark("afterIOWrite");
                     performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");
+
+                    if (emittedFiles) {
+                        emittedFiles.push(fileName);
+                    }
                 }
                 catch (e) {
-                    return createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, fileName, e);
-                }
-            }
-
-            function writeOutputFiles(outputFiles: OutputFile[]) {
-                if (outputFiles) {
-                    for (const outputFile of outputFiles) {
-                        const error = writeFile(outputFile.name, outputFile.text, outputFile.writeByteOrderMark);
-                        if (error) {
-                            diagnostics.push(error);
-                        }
-                        if (emittedFiles) {
-                            emittedFiles.push(outputFile.name);
-                        }
+                    if (onError) {
+                        onError(e.message);
                     }
                 }
             }
@@ -249,10 +241,10 @@ namespace ts {
         let hasChangedAutomaticTypeDirectiveNames = false;                  // True if the automatic type directives have changed
 
         const loggingEnabled = compilerOptions.diagnostics || compilerOptions.extendedDiagnostics;
-        const writeLog: (s: string) => void = loggingEnabled ? s => system.write(s) : noop;
-        const watchFile = loggingEnabled ? ts.addFileWatcherWithLogging : ts.addFileWatcher;
-        const watchFilePath = loggingEnabled ? ts.addFilePathWatcherWithLogging : ts.addFilePathWatcher;
-        const watchDirectoryWorker = loggingEnabled ? ts.addDirectoryWatcherWithLogging : ts.addDirectoryWatcher;
+        const writeLog: (s: string) => void = loggingEnabled ? s => { system.write(s); system.write(system.newLine); } : noop;
+        const watchFile = compilerOptions.extendedDiagnostics ? ts.addFileWatcherWithLogging : loggingEnabled ? ts.addFileWatcherWithOnlyTriggerLogging : ts.addFileWatcher;
+        const watchFilePath = compilerOptions.extendedDiagnostics ? ts.addFilePathWatcherWithLogging : ts.addFilePathWatcher;
+        const watchDirectoryWorker = compilerOptions.extendedDiagnostics ? ts.addDirectoryWatcherWithLogging : ts.addDirectoryWatcher;
 
         watchingHost = watchingHost || createWatchingSystemHost(compilerOptions.pretty);
         const { system, parseConfigFile, reportDiagnostic, reportWatchDiagnostic, beforeCompile, afterCompile } = watchingHost;
@@ -308,7 +300,7 @@ namespace ts {
             getCurrentDirectory()
         );
         // There is no extra check needed since we can just rely on the program to decide emit
-        const builder = createBuilder({ getCanonicalFileName, getEmitOutput: getFileEmitOutput, computeHash, shouldEmitFile: () => true });
+        const builder = createBuilder({ getCanonicalFileName, computeHash });
 
         synchronizeProgram();
 
@@ -322,6 +314,9 @@ namespace ts {
 
             if (hasChangedCompilerOptions) {
                 newLine = getNewLineCharacter(compilerOptions, system);
+                if (program && changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
+                    resolutionCache.clear();
+                }
             }
 
             const hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution();
@@ -329,14 +324,11 @@ namespace ts {
                 return;
             }
 
-            if (hasChangedCompilerOptions && changesAffectModuleResolution(program && program.getCompilerOptions(), compilerOptions)) {
-                resolutionCache.clear();
-            }
-            const needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !program;
-            hasChangedCompilerOptions = false;
             beforeCompile(compilerOptions);
 
             // Compile the program
+            const needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !program;
+            hasChangedCompilerOptions = false;
             resolutionCache.startCachingPerDirectoryResolution();
             compilerHost.hasInvalidatedResolution = hasInvalidatedResolution;
             compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
@@ -605,8 +597,17 @@ namespace ts {
                     const fileOrDirectoryPath = toPath(fileOrDirectory);
 
                     // Since the file existance changed, update the sourceFiles cache
-                    (directoryStructureHost as CachedDirectoryStructureHost).addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
-                    removeSourceFile(fileOrDirectoryPath);
+                    const result = (directoryStructureHost as CachedDirectoryStructureHost).addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
+
+                    // Instead of deleting the file, mark it as changed instead
+                    // Many times node calls add/remove/file when watching directories recursively
+                    const hostSourceFile = sourceFilesCache.get(fileOrDirectoryPath);
+                    if (hostSourceFile && !isString(hostSourceFile) && (result ? result.fileExists : directoryStructureHost.fileExists(fileOrDirectory))) {
+                        hostSourceFile.version++;
+                    }
+                    else {
+                        removeSourceFile(fileOrDirectoryPath);
+                    }
 
                     // If the the added or created file or directory is not supported file name, ignore the file
                     // But when watched directory is added/removed, we need to reload the file list

src/compiler/watchUtilities.ts

@@ -1,5 +1,6 @@
 /// <reference path="core.ts" />
 
+/* @internal */
 namespace ts {
     /**
      * Updates the existing missing file watches with the new set of missing files after new program is created
@@ -72,17 +73,19 @@ namespace ts {
             existingWatchedForWildcards.set(directory, createWildcardDirectoryWatcher(directory, flags));
         }
     }
-}
 
-/* @internal */
-namespace ts {
     export function addFileWatcher(host: System, file: string, cb: FileWatcherCallback): FileWatcher {
         return host.watchFile(file, cb);
     }
 
     export function addFileWatcherWithLogging(host: System, file: string, cb: FileWatcherCallback, log: (s: string) => void): FileWatcher {
         const watcherCaption = `FileWatcher:: `;
-        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, host, file, cb);
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ false, host, file, cb);
+    }
+
+    export function addFileWatcherWithOnlyTriggerLogging(host: System, file: string, cb: FileWatcherCallback, log: (s: string) => void): FileWatcher {
+        const watcherCaption = `FileWatcher:: `;
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ true, host, file, cb);
     }
 
     export type FilePathWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind, filePath: Path) => void;
@@ -92,7 +95,12 @@ namespace ts {
 
     export function addFilePathWatcherWithLogging(host: System, file: string, cb: FilePathWatcherCallback, path: Path, log: (s: string) => void): FileWatcher {
         const watcherCaption = `FileWatcher:: `;
-        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, host, file, cb, path);
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ false, host, file, cb, path);
+    }
+
+    export function addFilePathWatcherWithOnlyTriggerLogging(host: System, file: string, cb: FilePathWatcherCallback, path: Path, log: (s: string) => void): FileWatcher {
+        const watcherCaption = `FileWatcher:: `;
+        return createWatcherWithLogging(addFileWatcher, watcherCaption, log, /*logOnlyTrigger*/ true, host, file, cb, path);
     }
 
     export function addDirectoryWatcher(host: System, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags): FileWatcher {
@@ -102,14 +110,21 @@ namespace ts {
 
     export function addDirectoryWatcherWithLogging(host: System, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags, log: (s: string) => void): FileWatcher {
         const watcherCaption = `DirectoryWatcher ${(flags & WatchDirectoryFlags.Recursive) !== 0 ? "recursive" : ""}:: `;
-        return createWatcherWithLogging(addDirectoryWatcher, watcherCaption, log, host, directory, cb, flags);
+        return createWatcherWithLogging(addDirectoryWatcher, watcherCaption, log, /*logOnlyTrigger*/ false, host, directory, cb, flags);
+    }
+
+    export function addDirectoryWatcherWithOnlyTriggerLogging(host: System, directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags, log: (s: string) => void): FileWatcher {
+        const watcherCaption = `DirectoryWatcher ${(flags & WatchDirectoryFlags.Recursive) !== 0 ? "recursive" : ""}:: `;
+        return createWatcherWithLogging(addDirectoryWatcher, watcherCaption, log, /*logOnlyTrigger*/ true, host, directory, cb, flags);
     }
 
     type WatchCallback<T, U> = (fileName: string, cbOptional1?: T, optional?: U) => void;
     type AddWatch<T, U> = (host: System, file: string, cb: WatchCallback<T, U>, optional?: U) => FileWatcher;
-    function createWatcherWithLogging<T, U>(addWatch: AddWatch<T, U>, watcherCaption: string, log: (s: string) => void, host: System, file: string, cb: WatchCallback<T, U>, optional?: U): FileWatcher {
+    function createWatcherWithLogging<T, U>(addWatch: AddWatch<T, U>, watcherCaption: string, log: (s: string) => void, logOnlyTrigger: boolean, host: System, file: string, cb: WatchCallback<T, U>, optional?: U): FileWatcher {
         const info = `PathInfo: ${file}`;
-        log(`${watcherCaption}Added: ${info}`);
+        if (!logOnlyTrigger) {
+            log(`${watcherCaption}Added: ${info}`);
+        }
         const watcher = addWatch(host, file, (fileName, cbOptional1?) => {
             const optionalInfo = cbOptional1 !== undefined ? ` ${cbOptional1}` : "";
             log(`${watcherCaption}Trigger: ${fileName}${optionalInfo} ${info}`);
@@ -120,7 +135,9 @@ namespace ts {
         }, optional);
         return {
             close: () => {
-                log(`${watcherCaption}Close: ${info}`);
+                if (!logOnlyTrigger) {
+                    log(`${watcherCaption}Close: ${info}`);
+                }
                 watcher.close();
             }
         };

src/harness/compilerRunner.ts

@@ -48,7 +48,7 @@ class CompilerBaselineRunner extends RunnerBase {
     }
 
     public checkTestCodeOutput(fileName: string) {
-        describe("compiler tests for " + fileName, () => {
+        describe(`${this.testSuiteName} tests for ${fileName}`, () => {
             // Mocha holds onto the closure environment of the describe callback even after the test is done.
             // Everything declared here should be cleared out in the "after" callback.
             let justName: string;
@@ -80,9 +80,9 @@ class CompilerBaselineRunner extends RunnerBase {
                     tsConfigFiles.push(this.createHarnessTestFile(testCaseContent.tsConfigFileUnitData, rootDir, ts.combinePaths(rootDir, tsConfigOptions.configFilePath)));
                 }
                 else {
-                    const baseUrl = harnessSettings["baseUrl"];
+                    const baseUrl = harnessSettings.baseUrl;
                     if (baseUrl !== undefined && !ts.isRootedDiskPath(baseUrl)) {
-                        harnessSettings["baseUrl"] = ts.getNormalizedAbsolutePath(baseUrl, rootDir);
+                        harnessSettings.baseUrl = ts.getNormalizedAbsolutePath(baseUrl, rootDir);
                     }
                 }
 
@@ -94,7 +94,7 @@ class CompilerBaselineRunner extends RunnerBase {
                 toBeCompiled = [];
                 otherFiles = [];
 
-                if (testCaseContent.settings["noImplicitReferences"] || /require\(/.test(lastUnit.content) || /reference\spath/.test(lastUnit.content)) {
+                if (testCaseContent.settings.noImplicitReferences || /require\(/.test(lastUnit.content) || /reference\spath/.test(lastUnit.content)) {
                     toBeCompiled.push(this.createHarnessTestFile(lastUnit, rootDir));
                     units.forEach(unit => {
                         if (unit.name !== lastUnit.name) {
@@ -114,7 +114,7 @@ class CompilerBaselineRunner extends RunnerBase {
                 }
 
                 const output = Harness.Compiler.compileFiles(
-                    toBeCompiled, otherFiles, harnessSettings, /*options*/ tsConfigOptions, /*currentDirectory*/ harnessSettings["currentDirectory"]);
+                    toBeCompiled, otherFiles, harnessSettings, /*options*/ tsConfigOptions, /*currentDirectory*/ harnessSettings.currentDirectory);
 
                 options = output.options;
                 result = output.result;

src/harness/fourslash.ts

@@ -783,10 +783,10 @@ namespace FourSlash {
             });
         }
 
-        public verifyCompletionListContains(symbol: string, text?: string, documentation?: string, kind?: string, spanIndex?: number) {
+        public verifyCompletionListContains(symbol: string, text?: string, documentation?: string, kind?: string, spanIndex?: number, hasAction?: boolean) {
             const completions = this.getCompletionListAtCaret();
             if (completions) {
-                this.assertItemInCompletionList(completions.entries, symbol, text, documentation, kind, spanIndex);
+                this.assertItemInCompletionList(completions.entries, symbol, text, documentation, kind, spanIndex, hasAction);
             }
             else {
                 this.raiseError(`No completions at position '${this.currentCaretPosition}' when looking for '${symbol}'.`);
@@ -953,6 +953,10 @@ namespace FourSlash {
             return this.getChecker().getSymbolsInScope(node, ts.SymbolFlags.Value | ts.SymbolFlags.Type | ts.SymbolFlags.Namespace);
         }
 
+        public setTypesRegistry(map: ts.MapLike<void>): void {
+            this.languageServiceAdapterHost.typesRegistry = ts.createMapFromTemplate(map);
+        }
+
         public verifyTypeOfSymbolAtLocation(range: Range, symbol: ts.Symbol, expected: string): void {
             const node = this.goToAndGetNode(range);
             const checker = this.getChecker();
@@ -1127,7 +1131,7 @@ Actual: ${stringify(fullActual)}`);
         }
 
         private getCompletionEntryDetails(entryName: string) {
-            return this.languageService.getCompletionEntryDetails(this.activeFile.fileName, this.currentCaretPosition, entryName);
+            return this.languageService.getCompletionEntryDetails(this.activeFile.fileName, this.currentCaretPosition, entryName, this.formatCodeSettings);
         }
 
         private getReferencesAtCaret() {
@@ -2289,6 +2293,29 @@ Actual: ${stringify(fullActual)}`);
             this.applyCodeActions(this.getCodeFixActions(fileName, errorCode), index);
         }
 
+        public applyCodeActionFromCompletion(markerName: string, options: FourSlashInterface.VerifyCompletionActionOptions) {
+            this.goToMarker(markerName);
+
+            const actualCompletion = this.getCompletionListAtCaret().entries.find(e => e.name === options.name);
+
+            if (!actualCompletion.hasAction) {
+                this.raiseError(`Completion for ${options.name} does not have an associated action.`);
+            }
+
+            const details = this.getCompletionEntryDetails(options.name);
+            if (details.codeActions.length !== 1) {
+                this.raiseError(`Expected one code action, got ${details.codeActions.length}`);
+            }
+
+            if (details.codeActions[0].description !== options.description) {
+                this.raiseError(`Expected description to be:\n${options.description}\ngot:\n${details.codeActions[0].description}`);
+            }
+
+            this.applyCodeActions(details.codeActions);
+
+            this.verifyNewContent(options);
+        }
+
         public verifyRangeIs(expectedText: string, includeWhiteSpace?: boolean) {
             const ranges = this.getRanges();
             if (ranges.length !== 1) {
@@ -2360,6 +2387,10 @@ Actual: ${stringify(fullActual)}`);
                 this.applyEdits(change.fileName, change.textChanges, /*isFormattingEdit*/ false);
             }
 
+            this.verifyNewContent(options);
+        }
+
+        private verifyNewContent(options: FourSlashInterface.NewContentOptions) {
             if (options.newFileContent) {
                 assert(!options.newRangeContent);
                 this.verifyCurrentFileContent(options.newFileContent);
@@ -2381,7 +2412,7 @@ Actual: ${stringify(fullActual)}`);
             }));
 
             return ts.flatMap(ts.deduplicate(diagnosticsForCodeFix, ts.equalOwnProperties), diagnostic => {
-                if (errorCode && errorCode !== diagnostic.code) {
+                if (errorCode !== undefined && errorCode !== diagnostic.code) {
                     return;
                 }
 
@@ -2750,16 +2781,26 @@ Actual: ${stringify(fullActual)}`);
             }
         }
 
-        public verifyCodeFixAvailable(negative: boolean) {
-            const codeFix = this.getCodeFixActions(this.activeFile.fileName);
+        public verifyCodeFixAvailable(negative: boolean, info: FourSlashInterface.VerifyCodeFixAvailableOptions[] | undefined) {
+            const codeFixes = this.getCodeFixActions(this.activeFile.fileName);
 
-            if (negative && codeFix.length) {
-                this.raiseError(`verifyCodeFixAvailable failed - expected no fixes but found one.`);
+            if (negative) {
+                if (codeFixes.length) {
+                    this.raiseError(`verifyCodeFixAvailable failed - expected no fixes but found one.`);
+                }
+                return;
             }
 
-            if (!(negative || codeFix.length)) {
+            if (!codeFixes.length) {
                 this.raiseError(`verifyCodeFixAvailable failed - expected code fixes but none found.`);
             }
+            if (info) {
+                assert.equal(info.length, codeFixes.length);
+                ts.zipWith(codeFixes, info, (fix, info) => {
+                    assert.equal(fix.description, info.description);
+                    this.assertObjectsEqual(fix.commands, info.commands);
+                });
+            }
         }
 
         public verifyApplicableRefactorAvailableAtMarker(negative: boolean, markerName: string) {
@@ -2803,6 +2844,14 @@ Actual: ${stringify(fullActual)}`);
             }
         }
 
+        public verifyRefactor({ name, actionName, refactors }: FourSlashInterface.VerifyRefactorOptions) {
+            const selection = this.getSelection();
+
+            const actualRefactors = (this.languageService.getApplicableRefactors(this.activeFile.fileName, selection) || ts.emptyArray)
+                .filter(r => r.name === name && r.actions.some(a => a.name === actionName));
+            this.assertObjectsEqual(actualRefactors, refactors);
+        }
+
         public verifyApplicableRefactorAvailableForRange(negative: boolean) {
             const ranges = this.getRanges();
             if (!(ranges && ranges.length === 1)) {
@@ -2822,14 +2871,14 @@ Actual: ${stringify(fullActual)}`);
         public applyRefactor({ refactorName, actionName, actionDescription, newContent: newContentWithRenameMarker }: FourSlashInterface.ApplyRefactorOptions) {
             const range = this.getSelection();
             const refactors = this.languageService.getApplicableRefactors(this.activeFile.fileName, range);
-            const refactor = refactors.find(r => r.name === refactorName);
-            if (!refactor) {
+            const refactorsWithName = refactors.filter(r => r.name === refactorName);
+            if (refactorsWithName.length === 0) {
                 this.raiseError(`The expected refactor: ${refactorName} is not available at the marker location.\nAvailable refactors: ${refactors.map(r => r.name)}`);
             }
 
-            const action = refactor.actions.find(a => a.name === actionName);
+            const action = ts.firstDefined(refactorsWithName, refactor => refactor.actions.find(a => a.name === actionName));
             if (!action) {
-                this.raiseError(`The expected action: ${action} is not included in: ${refactor.actions.map(a => a.name)}`);
+                this.raiseError(`The expected action: ${actionName} is not included in: ${ts.flatMap(refactorsWithName, r => r.actions.map(a => a.name))}`);
             }
             if (action.description !== actionDescription) {
                 this.raiseError(`Expected action description to be ${JSON.stringify(actionDescription)}, got: ${JSON.stringify(action.description)}`);
@@ -2933,7 +2982,15 @@ Actual: ${stringify(fullActual)}`);
             return text.substring(startPos, endPos);
         }
 
-        private assertItemInCompletionList(items: ts.CompletionEntry[], name: string, text?: string, documentation?: string, kind?: string, spanIndex?: number) {
+        private assertItemInCompletionList(
+            items: ts.CompletionEntry[],
+            name: string,
+            text: string | undefined,
+            documentation: string | undefined,
+            kind: string | undefined,
+            spanIndex: number | undefined,
+            hasAction: boolean | undefined,
+        ) {
             for (const item of items) {
                 if (item.name === name) {
                     if (documentation !== undefined || text !== undefined) {
@@ -2956,6 +3013,8 @@ Actual: ${stringify(fullActual)}`);
                         assert.isTrue(TestState.textSpansEqual(span, item.replacementSpan), this.assertionMessageAtLastKnownMarker(stringify(span) + " does not equal " + stringify(item.replacementSpan) + " replacement span for " + name));
                     }
 
+                    assert.equal(item.hasAction, hasAction);
+
                     return;
                 }
             }
@@ -3222,7 +3281,7 @@ ${code}
     }
 
     function containTSConfigJson(files: FourSlashFile[]): boolean {
-        return ts.forEach(files, f => f.fileOptions["Filename"] === "tsconfig.json");
+        return ts.forEach(files, f => f.fileOptions.Filename === "tsconfig.json");
     }
 
     function getNonFileNameOptionInFileList(files: FourSlashFile[]): string {
@@ -3577,6 +3636,10 @@ namespace FourSlashInterface {
         public symbolsInScope(range: FourSlash.Range): ts.Symbol[] {
             return this.state.symbolsInScope(range);
         }
+
+        public setTypesRegistry(map: ts.MapLike<void>): void {
+            this.state.setTypesRegistry(map);
+        }
     }
 
     export class GoTo {
@@ -3669,12 +3732,12 @@ namespace FourSlashInterface {
 
         // Verifies the completion list contains the specified symbol. The
         // completion list is brought up if necessary
-        public completionListContains(symbol: string, text?: string, documentation?: string, kind?: string, spanIndex?: number) {
+        public completionListContains(symbol: string, text?: string, documentation?: string, kind?: string, spanIndex?: number, hasAction?: boolean) {
             if (this.negative) {
                 this.state.verifyCompletionListDoesNotContain(symbol, text, documentation, kind, spanIndex);
             }
             else {
-                this.state.verifyCompletionListContains(symbol, text, documentation, kind, spanIndex);
+                this.state.verifyCompletionListContains(symbol, text, documentation, kind, spanIndex, hasAction);
             }
         }
 
@@ -3752,8 +3815,8 @@ namespace FourSlashInterface {
             this.state.verifyCodeFix(options);
         }
 
-        public codeFixAvailable() {
-            this.state.verifyCodeFixAvailable(this.negative);
+        public codeFixAvailable(options?: VerifyCodeFixAvailableOptions[]) {
+            this.state.verifyCodeFixAvailable(this.negative, options);
         }
 
         public applicableRefactorAvailableAtMarker(markerName: string) {
@@ -3764,6 +3827,10 @@ namespace FourSlashInterface {
             this.state.verifyApplicableRefactorAvailableForRange(this.negative);
         }
 
+        public refactor(options: VerifyRefactorOptions) {
+            this.state.verifyRefactor(options);
+        }
+
         public refactorAvailable(name: string, actionName?: string) {
             this.state.verifyRefactorAvailable(this.negative, name, actionName);
         }
@@ -3999,6 +4066,10 @@ namespace FourSlashInterface {
             this.state.getAndApplyCodeActions(errorCode, index);
         }
 
+        public applyCodeActionFromCompletion(markerName: string, options: VerifyCompletionActionOptions): void {
+            this.state.applyCodeActionFromCompletion(markerName, options);
+        }
+
         public importFixAtPosition(expectedTextArray: string[], errorCode?: number): void {
             this.state.verifyImportFixAtPosition(expectedTextArray, errorCode);
         }
@@ -4396,12 +4467,31 @@ namespace FourSlashInterface {
         isNewIdentifierLocation?: boolean;
     }
 
-    export interface VerifyCodeFixOptions {
-        description: string;
-        // One of these should be defined.
+    export interface NewContentOptions {
+        // Exactly one of these should be defined.
         newFileContent?: string;
         newRangeContent?: string;
+    }
+
+    export interface VerifyCodeFixOptions extends NewContentOptions {
+        description: string;
         errorCode?: number;
         index?: number;
     }
+
+    export interface VerifyCodeFixAvailableOptions {
+        description: string;
+        commands?: ts.CodeActionCommand[];
+    }
+
+    export interface VerifyRefactorOptions {
+        name: string;
+        actionName: string;
+        refactors: ts.ApplicableRefactorInfo[];
+    }
+
+    export interface VerifyCompletionActionOptions extends NewContentOptions {
+        name: string;
+        description: string;
+    }
 }

src/harness/harness.ts

@@ -844,9 +844,7 @@ namespace Harness {
         export const es2015DefaultLibFileName = "lib.es2015.d.ts";
 
         // Cache of lib files from "built/local"
-        const libFileNameSourceFileMap = ts.createMapFromTemplate<ts.SourceFile>({
-            [defaultLibFileName]: createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts"), /*languageVersion*/ ts.ScriptTarget.Latest)
-        });
+        let libFileNameSourceFileMap: ts.Map<ts.SourceFile> | undefined;
 
         // Cache of lib files from  "tests/lib/"
         const testLibFileNameSourceFileMap = ts.createMap<ts.SourceFile>();
@@ -857,6 +855,12 @@ namespace Harness {
                 return undefined;
             }
 
+            if (!libFileNameSourceFileMap) {
+                libFileNameSourceFileMap = ts.createMapFromTemplate({
+                    [defaultLibFileName]: createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts"), /*languageVersion*/ ts.ScriptTarget.Latest)
+                });
+            }
+
             let sourceFile = libFileNameSourceFileMap.get(fileName);
             if (!sourceFile) {
                 libFileNameSourceFileMap.set(fileName, sourceFile = createSourceFileAndAssertInvariants(fileName, IO.readFile(libFolder + fileName), ts.ScriptTarget.Latest));
@@ -912,8 +916,8 @@ namespace Harness {
                 if (file.content !== undefined) {
                     const fileName = ts.normalizePath(file.unitName);
                     const path = ts.toPath(file.unitName, currentDirectory, getCanonicalFileName);
-                    if (file.fileOptions && file.fileOptions["symlink"]) {
-                        const links = file.fileOptions["symlink"].split(",");
+                    if (file.fileOptions && file.fileOptions.symlink) {
+                        const links = file.fileOptions.symlink.split(",");
                         for (const link of links) {
                             const linkPath = ts.toPath(link, currentDirectory, getCanonicalFileName);
                             realPathMap.set(linkPath, fileName);
@@ -1228,7 +1232,7 @@ namespace Harness {
             if (options.declaration && result.errors.length === 0 && result.declFilesCode.length > 0) {
                 ts.forEach(inputFiles, file => addDtsFile(file, declInputFiles));
                 ts.forEach(otherFiles, file => addDtsFile(file, declOtherFiles));
-                return { declInputFiles, declOtherFiles, harnessSettings, options, currentDirectory: currentDirectory || harnessSettings["currentDirectory"] };
+                return { declInputFiles, declOtherFiles, harnessSettings, options, currentDirectory: currentDirectory || harnessSettings.currentDirectory };
             }
 
             function addDtsFile(file: TestFile, dtsFiles: TestFile[]) {
@@ -1672,7 +1676,7 @@ namespace Harness {
         }
 
         function fileOutput(file: GeneratedFile, harnessSettings: Harness.TestCaseParser.CompilerSettings): string {
-            const fileName = harnessSettings["fullEmitPaths"] ? file.fileName : ts.getBaseFileName(file.fileName);
+            const fileName = harnessSettings.fullEmitPaths ? file.fileName : ts.getBaseFileName(file.fileName);
             return "//// [" + fileName + "]\r\n" + getByteOrderMarkText(file) + file.code;
         }
 

src/harness/harnessLanguageService.ts

@@ -123,6 +123,7 @@ namespace Harness.LanguageService {
     }
 
     export class LanguageServiceAdapterHost {
+        public typesRegistry: ts.Map<void> | undefined;
         protected virtualFileSystem: Utils.VirtualFileSystem = new Utils.VirtualFileSystem(virtualFileSystemRoot, /*useCaseSensitiveFilenames*/false);
 
         constructor(protected cancellationToken = DefaultHostCancellationToken.Instance,
@@ -182,6 +183,11 @@ namespace Harness.LanguageService {
 
     /// Native adapter
     class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost {
+        isKnownTypesPackageName(name: string): boolean {
+            return this.typesRegistry && this.typesRegistry.has(name);
+        }
+        installPackage = ts.notImplemented;
+
         getCompilationSettings() { return this.settings; }
         getCancellationToken() { return this.cancellationToken; }
         getDirectories(path: string): string[] {
@@ -206,6 +212,11 @@ namespace Harness.LanguageService {
             return script ? script.version.toString() : undefined;
         }
 
+        directoryExists(dirName: string): boolean {
+            const fileEntry = this.virtualFileSystem.traversePath(dirName);
+            return fileEntry && fileEntry.isDirectory();
+        }
+
         fileExists(fileName: string): boolean {
             const script = this.getScriptSnapshot(fileName);
             return script !== undefined;
@@ -405,8 +416,8 @@ namespace Harness.LanguageService {
         getCompletionsAtPosition(fileName: string, position: number): ts.CompletionInfo {
             return unwrapJSONCallResult(this.shim.getCompletionsAtPosition(fileName, position));
         }
-        getCompletionEntryDetails(fileName: string, position: number, entryName: string): ts.CompletionEntryDetails {
-            return unwrapJSONCallResult(this.shim.getCompletionEntryDetails(fileName, position, entryName));
+        getCompletionEntryDetails(fileName: string, position: number, entryName: string, options: ts.FormatCodeOptions): ts.CompletionEntryDetails {
+            return unwrapJSONCallResult(this.shim.getCompletionEntryDetails(fileName, position, entryName, JSON.stringify(options)));
         }
         getCompletionEntrySymbol(): ts.Symbol {
             throw new Error("getCompletionEntrySymbol not implemented across the shim layer.");
@@ -493,6 +504,7 @@ namespace Harness.LanguageService {
         getCodeFixesAtPosition(): ts.CodeAction[] {
             throw new Error("Not supported on the shim.");
         }
+        applyCodeActionCommand = ts.notImplemented;
         getCodeFixDiagnostics(): ts.Diagnostic[] {
             throw new Error("Not supported on the shim.");
         }

src/harness/loggedIO.ts

@@ -157,11 +157,20 @@ namespace Playback {
         return log;
     }
 
+    const canonicalizeForHarness = ts.createGetCanonicalFileName(/*caseSensitive*/ false); // This is done so tests work on windows _and_ linux
+    function sanitizeTestFilePath(name: string) {
+        const path = ts.toPath(ts.normalizeSlashes(name.replace(/[\^<>:"|?*%]/g, "_")).replace(/\.\.\//g, "__dotdot/"), "", canonicalizeForHarness);
+        if (ts.startsWith(path, "/")) {
+            return path.substring(1);
+        }
+        return path;
+    }
+
     export function oldStyleLogIntoNewStyleLog(log: IOLog, writeFile: typeof Harness.IO.writeFile, baseTestName: string) {
         if (log.filesAppended) {
             for (const file of log.filesAppended) {
                 if (file.contents !== undefined) {
-                    file.contentsPath = ts.combinePaths("appended", Harness.Compiler.sanitizeTestFilePath(file.path));
+                    file.contentsPath = ts.combinePaths("appended", sanitizeTestFilePath(file.path));
                     writeFile(ts.combinePaths(baseTestName, file.contentsPath), file.contents);
                     delete file.contents;
                 }
@@ -170,7 +179,7 @@ namespace Playback {
         if (log.filesWritten) {
             for (const file of log.filesWritten) {
                 if (file.contents !== undefined) {
-                    file.contentsPath = ts.combinePaths("written", Harness.Compiler.sanitizeTestFilePath(file.path));
+                    file.contentsPath = ts.combinePaths("written", sanitizeTestFilePath(file.path));
                     writeFile(ts.combinePaths(baseTestName, file.contentsPath), file.contents);
                     delete file.contents;
                 }
@@ -180,7 +189,7 @@ namespace Playback {
             for (const file of log.filesRead) {
                 const { contents } = file.result;
                 if (contents !== undefined) {
-                    file.result.contentsPath = ts.combinePaths("read", Harness.Compiler.sanitizeTestFilePath(file.path));
+                    file.result.contentsPath = ts.combinePaths("read", sanitizeTestFilePath(file.path));
                     writeFile(ts.combinePaths(baseTestName, file.result.contentsPath), contents);
                     const len = contents.length;
                     if (len >= 2 && contents.charCodeAt(0) === 0xfeff) {
@@ -235,8 +244,8 @@ namespace Playback {
             if (recordLog !== undefined) {
                 let i = 0;
                 const fn = () => recordLogFileNameBase + i;
-                while (underlying.fileExists(fn() + ".json")) i++;
-                underlying.writeFile(ts.combinePaths(fn(), "test.json"), JSON.stringify(oldStyleLogIntoNewStyleLog(recordLog, (path, string) => underlying.writeFile(ts.combinePaths(fn(), path), string), fn()), null, 4)); // tslint:disable-line:no-null-keyword
+                while (underlying.fileExists(ts.combinePaths(fn(), "test.json"))) i++;
+                underlying.writeFile(ts.combinePaths(fn(), "test.json"), JSON.stringify(oldStyleLogIntoNewStyleLog(recordLog, (path, string) => underlying.writeFile(path, string), fn()), null, 4)); // tslint:disable-line:no-null-keyword
                 recordLog = undefined;
             }
         };
@@ -415,4 +424,4 @@ namespace Playback {
         initWrapper(wrapper, underlying);
         return wrapper;
     }
-}
+}

src/harness/parallel/host.ts

@@ -38,20 +38,45 @@ namespace Harness.Parallel.Host {
         return undefined;
     }
 
-    function hashName(runner: TestRunnerKind, test: string) {
+    function hashName(runner: TestRunnerKind | "unittest", test: string) {
         return `tsrunner-${runner}://${test}`;
     }
 
+    let tasks: { runner: TestRunnerKind | "unittest", file: string, size: number }[] = [];
+    const newTasks: { runner: TestRunnerKind | "unittest", file: string, size: number }[] = [];
+    let unknownValue: string | undefined;
     export function start() {
-        initializeProgressBarsDependencies();
-        console.log("Discovering tests...");
-        const discoverStart = +(new Date());
-        const { statSync }: { statSync(path: string): { size: number }; } = require("fs");
-        let tasks: { runner: TestRunnerKind, file: string, size: number }[] = [];
-        const newTasks: { runner: TestRunnerKind, file: string, size: number }[] = [];
         const perfData = readSavedPerfData(configOption);
         let totalCost = 0;
-        let unknownValue: string | undefined;
+        if (runUnitTests) {
+            (global as any).describe = (suiteName: string) => {
+                // Note, sub-suites are not indexed (we assume such granularity is not required)
+                let size = 0;
+                if (perfData) {
+                    size = perfData[hashName("unittest", suiteName)];
+                    if (size === undefined) {
+                        newTasks.push({ runner: "unittest", file: suiteName, size: 0 });
+                        unknownValue = suiteName;
+                        return;
+                    }
+                }
+                tasks.push({ runner: "unittest", file: suiteName, size });
+                totalCost += size;
+            };
+        }
+        else {
+            (global as any).describe = ts.noop;
+        }
+
+        setTimeout(() => startDelayed(perfData, totalCost), 0); // Do real startup on next tick, so all unit tests have been collected
+    }
+
+    function startDelayed(perfData: {[testHash: string]: number}, totalCost: number) {
+        initializeProgressBarsDependencies();
+        console.log(`Discovered ${tasks.length} unittest suites` + (newTasks.length ? ` and ${newTasks.length} new suites.` : "."));
+        console.log("Discovering runner-based tests...");
+        const discoverStart = +(new Date());
+        const { statSync }: { statSync(path: string): { size: number }; } = require("fs");
         for (const runner of runners) {
             const files = runner.enumerateTestFiles();
             for (const file of files) {
@@ -87,8 +112,7 @@ namespace Harness.Parallel.Host {
         }
         tasks.sort((a, b) => a.size - b.size);
         tasks = tasks.concat(newTasks);
-        // 1 fewer batches than threads to account for unittests running on the final thread
-        const batchCount = runners.length === 1 ? workerCount : workerCount - 1;
+        const batchCount = workerCount;
         const packfraction = 0.9;
         const chunkSize = 1000; // ~1KB or 1s for sending batches near the end of a test
         const batchSize = (totalCost / workerCount) * packfraction; // Keep spare tests for unittest thread in reserve
@@ -113,7 +137,7 @@ namespace Harness.Parallel.Host {
         let closedWorkers = 0;
         for (let i = 0; i < workerCount; i++) {
             // TODO: Just send the config over the IPC channel or in the command line arguments
-            const config: TestConfig = { light: Harness.lightMode, listenForWork: true, runUnitTests: runners.length === 1 ? false : i === workerCount - 1 };
+            const config: TestConfig = { light: Harness.lightMode, listenForWork: true, runUnitTests };
             const configPath = ts.combinePaths(taskConfigsFolder, `task-config${i}.json`);
             Harness.IO.writeFile(configPath, JSON.stringify(config));
             const child = fork(__filename, [`--config="${configPath}"`]);
@@ -187,7 +211,7 @@ namespace Harness.Parallel.Host {
         // It's only really worth doing an initial batching if there are a ton of files to go through
         if (totalFiles > 1000) {
             console.log("Batching initial test lists...");
-            const batches: { runner: TestRunnerKind, file: string, size: number }[][] = new Array(batchCount);
+            const batches: { runner: TestRunnerKind | "unittest", file: string, size: number }[][] = new Array(batchCount);
             const doneBatching = new Array(batchCount);
             let scheduledTotal = 0;
             batcher: while (true) {
@@ -230,7 +254,7 @@ namespace Harness.Parallel.Host {
                 if (payload) {
                     worker.send({ type: "batch", payload });
                 }
-                else { // Unittest thread - send off just one test
+                else { // Out of batches, send off just one test
                     const payload = tasks.pop();
                     ts.Debug.assert(!!payload); // The reserve kept above should ensure there is always an initial task available, even in suboptimal scenarios
                     worker.send({ type: "test", payload });

src/harness/parallel/shared.ts

@@ -1,14 +1,14 @@
 /// <reference path="./host.ts" />
 /// <reference path="./worker.ts" />
 namespace Harness.Parallel {
-    export type ParallelTestMessage = { type: "test", payload: { runner: TestRunnerKind, file: string } } | never;
+    export type ParallelTestMessage = { type: "test", payload: { runner: TestRunnerKind | "unittest", file: string } } | never;
     export type ParallelBatchMessage = { type: "batch", payload: ParallelTestMessage["payload"][] } | never;
     export type ParallelCloseMessage = { type: "close" } | never;
     export type ParallelHostMessage = ParallelTestMessage | ParallelCloseMessage | ParallelBatchMessage;
 
     export type ParallelErrorMessage = { type: "error", payload: { error: string, stack: string, name?: string[] } } | never;
     export type ErrorInfo = ParallelErrorMessage["payload"] & { name: string[] };
-    export type ParallelResultMessage = { type: "result", payload: { passing: number, errors: ErrorInfo[], duration: number, runner: TestRunnerKind, file: string } } | never;
+    export type ParallelResultMessage = { type: "result", payload: { passing: number, errors: ErrorInfo[], duration: number, runner: TestRunnerKind | "unittest", file: string } } | never;
     export type ParallelBatchProgressMessage = { type: "progress", payload: ParallelResultMessage["payload"] } | never;
     export type ParallelClientMessage = ParallelErrorMessage | ParallelResultMessage | ParallelBatchProgressMessage;
 }

src/harness/parallel/worker.ts

@@ -1,22 +1,13 @@
 namespace Harness.Parallel.Worker {
     let errors: ErrorInfo[] = [];
     let passing = 0;
-    let reportedUnitTests = false;
 
     type Executor = {name: string, callback: Function, kind: "suite" | "test"} | never;
 
     function resetShimHarnessAndExecute(runner: RunnerBase) {
-        if (reportedUnitTests) {
-            errors = [];
-            passing = 0;
-            testList.length = 0;
-        }
-        reportedUnitTests = true;
-        if (testList.length) {
-            // Execute unit tests
-            testList.forEach(({ name, callback, kind }) => executeCallback(name, callback, kind));
-            testList.length = 0;
-        }
+        errors = [];
+        passing = 0;
+        testList.length = 0;
         const start = +(new Date());
         runner.initializeTests();
         testList.forEach(({ name, callback, kind }) => executeCallback(name, callback, kind));
@@ -226,13 +217,46 @@ namespace Harness.Parallel.Worker {
             shimMochaHarness();
         }
 
-        function handleTest(runner: TestRunnerKind, file: string) {
-            if (!runners.has(runner)) {
-                runners.set(runner, createRunner(runner));
+        function handleTest(runner: TestRunnerKind | "unittest", file: string) {
+            collectUnitTestsIfNeeded();
+            if (runner === unittest) {
+                return executeUnitTest(file);
+            }
+            else {
+                if (!runners.has(runner)) {
+                    runners.set(runner, createRunner(runner));
+                }
+                const instance = runners.get(runner);
+                instance.tests = [file];
+                return { ...resetShimHarnessAndExecute(instance), runner, file };
             }
-            const instance = runners.get(runner);
-            instance.tests = [file];
-            return { ...resetShimHarnessAndExecute(instance), runner, file };
         }
     }
+
+    const unittest: "unittest" = "unittest";
+    let unitTests: {[name: string]: Function};
+    function collectUnitTestsIfNeeded() {
+        if (!unitTests && testList.length) {
+            unitTests = {};
+            for (const test of testList) {
+                unitTests[test.name] = test.callback;
+            }
+            testList.length = 0;
+        }
+    }
+
+    function executeUnitTest(name: string) {
+        if (!unitTests) {
+            throw new Error(`Asked to run unit test ${name}, but no unit tests were discovered!`);
+        }
+        if (unitTests[name]) {
+            errors = [];
+            passing = 0;
+            const start = +(new Date());
+            executeSuiteCallback(name, unitTests[name]);
+            delete unitTests[name];
+            return { file: name, runner: unittest, errors, passing, duration: +(new Date()) - start };
+        }
+        throw new Error(`Unit test with name "${name}" was asked to be run, but such a test does not exist!`);
+    }
 }

src/harness/projectsRunner.ts

@@ -443,7 +443,7 @@ class ProjectRunner extends RunnerBase {
 
         const name = "Compiling project for " + testCase.scenario + ": testcase " + testCaseFileName;
 
-        describe("Projects tests", () => {
+        describe("projects tests", () => {
             describe(name, () => {
                 function verifyCompilerResults(moduleKind: ts.ModuleKind) {
                     let compilerResult: BatchCompileProjectTestCaseResult;

src/harness/runner.ts

@@ -82,7 +82,7 @@ let testConfigContent =
 
 let taskConfigsFolder: string;
 let workerCount: number;
-let runUnitTests = true;
+let runUnitTests: boolean | undefined;
 let noColors = false;
 
 interface TestConfig {
@@ -108,9 +108,7 @@ function handleTestConfig() {
         if (testConfig.light) {
             Harness.lightMode = true;
         }
-        if (testConfig.runUnitTests !== undefined) {
-            runUnitTests = testConfig.runUnitTests;
-        }
+        runUnitTests = testConfig.runUnitTests;
         if (testConfig.workerCount) {
             workerCount = +testConfig.workerCount;
         }
@@ -199,6 +197,9 @@ function handleTestConfig() {
         runners.push(new FourSlashRunner(FourSlashTestType.Server));
         // runners.push(new GeneratedFourslashRunner());
     }
+    if (runUnitTests === undefined) {
+        runUnitTests = runners.length !== 1; // Don't run unit tests when running only one runner if unit tests were not explicitly asked for
+    }
 }
 
 function beginTests() {

src/harness/rwcRunner.ts

@@ -26,7 +26,7 @@ namespace RWC {
     }
 
     export function runRWCTest(jsonPath: string) {
-        describe("Testing a RWC project: " + jsonPath, () => {
+        describe("Testing a rwc project: " + jsonPath, () => {
             let inputFiles: Harness.Compiler.TestFile[] = [];
             let otherFiles: Harness.Compiler.TestFile[] = [];
             let tsconfigFiles: Harness.Compiler.TestFile[] = [];
@@ -266,6 +266,7 @@ class RWCRunner extends RunnerBase {
     public initializeTests(): void {
         // Read in and evaluate the test list
         const testList = this.tests && this.tests.length ? this.tests : this.enumerateTestFiles();
+
         for (let i = 0; i < testList.length; i++) {
             this.runTest(testList[i]);
         }

src/harness/tsconfig.json

@@ -139,6 +139,7 @@
         "./unittests/telemetry.ts",
         "./unittests/languageService.ts",
         "./unittests/programMissingFiles.ts",
-        "./unittests/publicApi.ts"
+        "./unittests/publicApi.ts",
+        "./unittests/hostNewLineSupport.ts"
     ]
 }

src/harness/typeWriter.ts

@@ -101,8 +101,8 @@ class TypeWriterWalker {
                 }
                 count++;
                 symbolString += ", ";
-                if ((declaration as any)["__symbolTestOutputCache"]) {
-                    symbolString += (declaration as any)["__symbolTestOutputCache"];
+                if ((declaration as any).__symbolTestOutputCache) {
+                    symbolString += (declaration as any).__symbolTestOutputCache;
                     continue;
                 }
                 const declSourceFile = declaration.getSourceFile();
@@ -111,7 +111,7 @@ class TypeWriterWalker {
                 const isLibFile = /lib(.*)\.d\.ts/i.test(fileName);
                 const declText = `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`;
                 symbolString += declText;
-                (declaration as any)["__symbolTestOutputCache"] = declText;
+                (declaration as any).__symbolTestOutputCache = declText;
             }
         }
         symbolString += ")";

src/harness/unittests/builder.ts

@@ -46,15 +46,14 @@ namespace ts {
     function makeAssertChanges(getProgram: () => Program): (fileNames: ReadonlyArray<string>) => void  {
         const builder = createBuilder({
             getCanonicalFileName: identity,
-            getEmitOutput: getFileEmitOutput,
-            computeHash: identity,
-            shouldEmitFile: returnTrue,
+            computeHash: identity
         });
         return fileNames => {
             const program = getProgram();
             builder.updateProgram(program);
-            const changedFiles = builder.emitChangedFiles(program);
-            assert.deepEqual(changedFileNames(changedFiles), fileNames);
+            const outputFileNames: string[] = [];
+            builder.emitChangedFiles(program, fileName => outputFileNames.push(fileName));
+            assert.deepEqual(outputFileNames, fileNames);
         };
     }
 
@@ -63,11 +62,4 @@ namespace ts {
             updateProgramText(files, fileName, fileContent);
         });
     }
-
-    function changedFileNames(changedFiles: ReadonlyArray<EmitOutputDetailed>): string[] {
-        return changedFiles.map(f => {
-            assert.lengthOf(f.outputFiles, 1);
-            return f.outputFiles[0].name;
-        });
-    }
 }

src/harness/unittests/compileOnSave.ts

@@ -12,7 +12,7 @@ namespace ts.projectSystem {
 
     describe("CompileOnSave affected list", () => {
         function sendAffectedFileRequestAndCheckResult(session: server.Session, request: server.protocol.Request, expectedFileList: { projectFileName: string, files: FileOrFolder[] }[]) {
-            const response: server.protocol.CompileOnSaveAffectedFileListSingleProject[] = session.executeCommand(request).response;
+            const response = session.executeCommand(request).response as server.protocol.CompileOnSaveAffectedFileListSingleProject[];
             const actualResult = response.sort((list1, list2) => compareStrings(list1.projectFileName, list2.projectFileName));
             expectedFileList = expectedFileList.sort((list1, list2) => compareStrings(list1.projectFileName, list2.projectFileName));
 
@@ -563,7 +563,7 @@ namespace ts.projectSystem {
                 path: "/a/b/file3.js",
                 content: "console.log('file3');"
             };
-            const externalProjectName = "externalproject";
+            const externalProjectName = "/a/b/externalproject";
             const host = createServerHost([file1, file2, file3, libFile]);
             const session = createSession(host);
             const projectService = session.getProjectService();
@@ -588,5 +588,48 @@ namespace ts.projectSystem {
             assert.isTrue(outFileContent.indexOf(file2.content) === -1);
             assert.isTrue(outFileContent.indexOf(file3.content) === -1);
         });
+
+        it("should use project root as current directory so that compile on save results in correct file mapping", () => {
+            const inputFileName = "Foo.ts";
+            const file1 = {
+                path: `/root/TypeScriptProject3/TypeScriptProject3/${inputFileName}`,
+                content: "consonle.log('file1');"
+            };
+            const externalProjectName = "/root/TypeScriptProject3/TypeScriptProject3/TypeScriptProject3.csproj";
+            const host = createServerHost([file1, libFile]);
+            const session = createSession(host);
+            const projectService = session.getProjectService();
+
+            const outFileName = "bar.js";
+            projectService.openExternalProject({
+                rootFiles: toExternalFiles([file1.path]),
+                options: {
+                    outFile: outFileName,
+                    sourceMap: true,
+                    compileOnSave: true
+                },
+                projectFileName: externalProjectName
+            });
+
+            const emitRequest = makeSessionRequest<server.protocol.CompileOnSaveEmitFileRequestArgs>(CommandNames.CompileOnSaveEmitFile, { file: file1.path });
+            session.executeCommand(emitRequest);
+
+            // Verify js file
+            const expectedOutFileName = "/root/TypeScriptProject3/TypeScriptProject3/" + outFileName;
+            assert.isTrue(host.fileExists(expectedOutFileName));
+            const outFileContent = host.readFile(expectedOutFileName);
+            verifyContentHasString(outFileContent, file1.content);
+            verifyContentHasString(outFileContent, `//# ${"sourceMappingURL"}=${outFileName}.map`); // Sometimes tools can sometimes see this line as a source mapping url comment, so we obfuscate it a little
+
+            // Verify map file
+            const expectedMapFileName = expectedOutFileName + ".map";
+            assert.isTrue(host.fileExists(expectedMapFileName));
+            const mapFileContent = host.readFile(expectedMapFileName);
+            verifyContentHasString(mapFileContent, `"sources":["${inputFileName}"]`);
+
+            function verifyContentHasString(content: string, string: string) {
+                assert.isTrue(content.indexOf(string) !== -1, `Expected "${content}" to have "${string}"`);
+            }
+        });
     });
 }

src/harness/unittests/convertCompilerOptionsFromJson.ts

@@ -9,7 +9,7 @@ namespace ts {
         }
 
         function assertCompilerOptionsWithJson(json: any, configFileName: string, expectedResult: { compilerOptions: CompilerOptions, errors: Diagnostic[] }) {
-            const { options: actualCompilerOptions, errors: actualErrors} = convertCompilerOptionsFromJson(json["compilerOptions"], "/apath/", configFileName);
+            const { options: actualCompilerOptions, errors: actualErrors} = convertCompilerOptionsFromJson(json.compilerOptions, "/apath/", configFileName);
 
             const parsedCompilerOptions = JSON.stringify(actualCompilerOptions);
             const expectedCompilerOptions = JSON.stringify(expectedResult.compilerOptions);
@@ -33,7 +33,7 @@ namespace ts {
             assert(!!result.endOfFileToken);
             const host: ParseConfigHost = new Utils.MockParseConfigHost("/apath/", true, []);
             const { options: actualCompilerOptions, errors: actualParseErrors } = parseJsonSourceFileConfigFileContent(result, host, "/apath/", /*existingOptions*/ undefined, configFileName);
-            expectedResult.compilerOptions["configFilePath"] = configFileName;
+            expectedResult.compilerOptions.configFilePath = configFileName;
 
             const parsedCompilerOptions = JSON.stringify(actualCompilerOptions);
             const expectedCompilerOptions = JSON.stringify(expectedResult.compilerOptions);

src/harness/unittests/convertTypeAcquisitionFromJson.ts

@@ -32,7 +32,7 @@ namespace ts {
         }
 
         function assertTypeAcquisitionWithJson(json: any, configFileName: string, expectedResult: ExpectedResult) {
-            const jsonOptions = json["typeAcquisition"] || json["typingOptions"];
+            const jsonOptions = json.typeAcquisition || json.typingOptions;
             const { options: actualTypeAcquisition, errors: actualErrors } = convertTypeAcquisitionFromJson(jsonOptions, "/apath/", configFileName);
             verifyAcquisition(actualTypeAcquisition, expectedResult);
             verifyErrors(actualErrors, expectedResult);

src/harness/unittests/extractConstants.ts

@@ -223,6 +223,14 @@ const f = () => {
         testExtractConstant("extractConstant_ArrowFunction_Expression",
             `const f = () => [#|2 + 1|];`);
 
+        testExtractConstant("extractConstant_PreserveTrivia", `
+// a
+var q = /*b*/ //c
+    /*d*/ [#|1 /*e*/ //f
+    /*g*/ + /*h*/ //i
+    /*j*/ 2|] /*k*/ //l
+    /*m*/; /*n*/ //o`);
+
         testExtractConstantFailed("extractConstant_Void", `
 function f(): void { }
 [#|f();|]`);
@@ -230,6 +238,30 @@ function f(): void { }
         testExtractConstantFailed("extractConstant_Never", `
 function f(): never { }
 [#|f();|]`);
+
+        testExtractConstant("extractConstant_This_Constructor", `
+class C {
+    constructor() {
+        [#|this.m2()|];
+    }
+    m2() { return 1; }
+}`);
+
+        testExtractConstant("extractConstant_This_Method", `
+class C {
+    m1() {
+        [#|this.m2()|];
+    }
+    m2() { return 1; }
+}`);
+
+        testExtractConstant("extractConstant_This_Property", `
+namespace N { // Force this test to be TS-only
+    class C {
+        x = 1;
+        y = [#|this.x|];
+    }
+}`);
     });
 
     function testExtractConstant(caption: string, text: string) {

src/harness/unittests/extractFunctions.ts

@@ -195,12 +195,12 @@ namespace ts {
     function G<U extends T[]>(t2: U) {
         [#|t2.toString();|]
     }
-}`);
+}`, /*includeLib*/ true);
         // Confirm that the contextual type of an extracted expression counts as a use.
         testExtractFunction("extractFunction16",
             `function F<T>() {
     const array: T[] = [#|[]|];
-}`);
+}`, /*includeLib*/ true);
         // Class type parameter
         testExtractFunction("extractFunction17",
             `class C<T1, T2> {
@@ -219,7 +219,7 @@ namespace ts {
         testExtractFunction("extractFunction19",
             `function F<T, U extends T[], V extends U[]>(v: V) {
     [#|v.toString()|];
-}`);
+}`, /*includeLib*/ true);
 
         testExtractFunction("extractFunction20",
         `const _ = class {
@@ -360,9 +360,189 @@ function parsePrimaryExpression(): any {
     export const j = 10;
     export const y = [#|j * j|];
 }`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Var", `
+[#|var x = 1;|]
+x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Let_Type", `
+[#|let x: number = 1;|]
+x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Let_NoType", `
+[#|let x = 1;|]
+x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Const_Type", `
+[#|const x: number = 1;|]
+x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Const_NoType", `
+[#|const x = 1;|]
+x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Multiple1", `
+[#|const x = 1, y: string = "a";|]
+x; y;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Multiple2", `
+[#|const x = 1, y = "a";
+const z = 3;|]
+x; y; z;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Multiple3", `
+[#|const x = 1, y: string = "a";
+let z = 3;|]
+x; y; z;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_ConsumedTwice", `
+[#|const x: number = 1;|]
+x; x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_DeclaredTwice", `
+[#|var x = 1;
+var x = 2;|]
+x;
+`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Var", `
+function f() {
+    let a = 1;
+    [#|var x = 1;
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Let_NoType", `
+function f() {
+    let a = 1;
+    [#|let x = 1;
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Let_Type", `
+function f() {
+    let a = 1;
+    [#|let x: number = 1;
+    a++;|]
+    a; x;
+}`);
+
+        // We propagate numericLiteralFlags, but it's not consumed by the emitter,
+        // so everything comes out decimal.  It would be nice to improve this.
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Let_LiteralType1", `
+function f() {
+    let a = 1;
+    [#|let x: 0o10 | 10 | 0b10 = 10;
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Let_LiteralType2", `
+function f() {
+    let a = 1;
+    [#|let x: "a" | 'b' = 'a';
+    a++;|]
+    a; x;
+}`);
+
+        // We propagate numericLiteralFlags, but it's not consumed by the emitter,
+        // so everything comes out decimal.  It would be nice to improve this.
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Let_LiteralType1", `
+function f() {
+    let a = 1;
+    [#|let x: 0o10 | 10 | 0b10 = 10;
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Let_TypeWithComments", `
+function f() {
+    let a = 1;
+    [#|let x: /*A*/ "a" /*B*/ | /*C*/ 'b' /*D*/ = 'a';
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Const_NoType", `
+function f() {
+    let a = 1;
+    [#|const x = 1;
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Const_Type", `
+function f() {
+    let a = 1;
+    [#|const x: number = 1;
+    a++;|]
+    a; x;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Mixed1", `
+function f() {
+    let a = 1;
+    [#|const x = 1;
+    let y = 2;
+    a++;|]
+    a; x; y;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Mixed2", `
+function f() {
+    let a = 1;
+    [#|var x = 1;
+    let y = 2;
+    a++;|]
+    a; x; y;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_Mixed3", `
+function f() {
+    let a = 1;
+    [#|let x: number = 1;
+    let y = 2;
+    a++;|]
+    a; x; y;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_Writes_UnionUndefined", `
+function f() {
+    let a = 1;
+    [#|let x: number | undefined = 1;
+    let y: undefined | number = 2;
+    let z: (undefined | number) = 3;
+    a++;|]
+    a; x; y; z;
+}`);
+
+        testExtractFunction("extractFunction_VariableDeclaration_ShorthandProperty", `
+function f() {
+    [#|let x;|]
+    return { x };
+}`);
+
+        testExtractFunction("extractFunction_PreserveTrivia", `
+// a
+var q = /*b*/ //c
+    /*d*/ [#|1 /*e*/ //f
+    /*g*/ + /*h*/ //i
+    /*j*/ 2|] /*k*/ //l
+    /*m*/; /*n*/ //o`);
     });
 
-    function testExtractFunction(caption: string, text: string) {
-        testExtractSymbol(caption, text, "extractFunction", Diagnostics.Extract_function);
+    function testExtractFunction(caption: string, text: string, includeLib?: boolean) {
+        testExtractSymbol(caption, text, "extractFunction", Diagnostics.Extract_function, includeLib);
     }
 }

src/harness/unittests/extractRanges.ts

@@ -152,6 +152,16 @@ namespace ts {
                     }
                 }
             `);
+            testExtractRange(`
+                function f(x: number) {
+                    [#|[$|try {
+                        x++;
+                    }
+                    finally {
+                        return 1;
+                    }|]|]
+                }
+            `);
         });
 
         testExtractRangeFailed("extractRangeFailed1",
@@ -313,6 +323,23 @@ switch (x) {
             refactor.extractSymbol.Messages.CannotExtractRange.message
         ]);
 
+        testExtractRangeFailed("extractRangeFailed11",
+        `
+            function f(x: number) {
+                while (true) {
+                    [#|try {
+                        x++;
+                    }
+                    finally {
+                        break;
+                    }|]
+                }
+            }
+        `,
+        [
+            refactor.extractSymbol.Messages.CannotExtractRangeContainingConditionalBreakOrContinueStatements.message
+        ]);
+
         testExtractRangeFailed("extract-method-not-for-token-expression-statement", `[#|a|]`, [refactor.extractSymbol.Messages.CannotExtractIdentifier.message]);
     });
 }

src/harness/unittests/extractTestHelpers.ts

@@ -97,7 +97,16 @@ namespace ts {
         return rulesProvider;
     }
 
-    export function testExtractSymbol(caption: string, text: string, baselineFolder: string, description: DiagnosticMessage) {
+    const notImplementedHost: LanguageServiceHost = {
+        getCompilationSettings: notImplemented,
+        getScriptFileNames: notImplemented,
+        getScriptVersion: notImplemented,
+        getScriptSnapshot: notImplemented,
+        getDefaultLibFileName: notImplemented,
+        getCurrentDirectory: notImplemented,
+    };
+
+    export function testExtractSymbol(caption: string, text: string, baselineFolder: string, description: DiagnosticMessage, includeLib?: boolean) {
         const t = extractTest(text);
         const selectionRange = t.ranges.get("selection");
         if (!selectionRange) {
@@ -109,7 +118,7 @@ namespace ts {
 
         function runBaseline(extension: Extension) {
             const path = "/a" + extension;
-            const program = makeProgram({ path, content: t.source });
+            const program = makeProgram({ path, content: t.source }, includeLib);
 
             if (hasSyntacticDiagnostics(program)) {
                 // Don't bother generating JS baselines for inputs that aren't valid JS.
@@ -125,6 +134,7 @@ namespace ts {
                 file: sourceFile,
                 startPosition: selectionRange.start,
                 endPosition: selectionRange.end,
+                host: notImplementedHost,
                 rulesProvider: getRuleProvider()
             };
             const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));
@@ -144,15 +154,15 @@ namespace ts {
                     const newTextWithRename = newText.slice(0, renameLocation) + "/*RENAME*/" + newText.slice(renameLocation);
                     data.push(newTextWithRename);
 
-                    const diagProgram = makeProgram({ path, content: newText });
+                    const diagProgram = makeProgram({ path, content: newText }, includeLib);
                     assert.isFalse(hasSyntacticDiagnostics(diagProgram));
                 }
                 return data.join(newLineCharacter);
             });
         }
 
-        function makeProgram(f: {path: string, content: string }) {
-            const host = projectSystem.createServerHost([f, projectSystem.libFile]);
+        function makeProgram(f: {path: string, content: string }, includeLib?: boolean) {
+            const host = projectSystem.createServerHost(includeLib ? [f, projectSystem.libFile] : [f]); // libFile is expensive to parse repeatedly - only test when required
             const projectService = projectSystem.createProjectService(host);
             projectService.openClientFile(f.path);
             const program = projectService.inferredProjects[0].getLanguageService().getProgram();
@@ -188,6 +198,7 @@ namespace ts {
                 file: sourceFile,
                 startPosition: selectionRange.start,
                 endPosition: selectionRange.end,
+                host: notImplementedHost,
                 rulesProvider: getRuleProvider()
             };
             const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromBounds(selectionRange.start, selectionRange.end));

src/harness/unittests/hostNewLineSupport.ts

@@ -0,0 +1,67 @@
+/// <reference path="..\harness.ts" />
+namespace ts {
+    describe("hostNewLineSupport", () => {
+        function testLSWithFiles(settings: CompilerOptions, files: Harness.Compiler.TestFile[]) {
+            function snapFor(path: string): IScriptSnapshot {
+                if (path === "lib.d.ts") {
+                    return {
+                        dispose() {},
+                        getChangeRange() { return undefined; },
+                        getLength() { return 0; },
+                        getText(_start, _end) {
+                            return "";
+                        }
+                    };
+                }
+                const result = forEach(files, f => f.unitName === path ? f : undefined);
+                if (result) {
+                    return {
+                        dispose() {},
+                        getChangeRange() { return undefined; },
+                        getLength() { return result.content.length; },
+                        getText(start, end) {
+                            return result.content.substring(start, end);
+                        }
+                    };
+                }
+                return undefined;
+            }
+            const lshost: LanguageServiceHost = {
+                getCompilationSettings: () => settings,
+                getScriptFileNames: () => map(files, f => f.unitName),
+                getScriptVersion: () => "1",
+                getScriptSnapshot: name => snapFor(name),
+                getDefaultLibFileName: () => "lib.d.ts",
+                getCurrentDirectory: () => "",
+            };
+            return ts.createLanguageService(lshost);
+        }
+
+        function verifyNewLines(content: string, options: CompilerOptions) {
+            const ls = testLSWithFiles(options, [{
+                content,
+                fileOptions: {},
+                unitName: "input.ts"
+            }]);
+            const result = ls.getEmitOutput("input.ts");
+            assert(!result.emitSkipped, "emit was skipped");
+            assert(result.outputFiles.length === 1, "a number of files other than 1 was output");
+            assert(result.outputFiles[0].name === "input.js", `Expected output file name input.js, but got ${result.outputFiles[0].name}`);
+            assert(result.outputFiles[0].text.match(options.newLine === NewLineKind.CarriageReturnLineFeed ? /\r\n/ : /[^\r]\n/), "expected to find appropriate newlines");
+            assert(!result.outputFiles[0].text.match(options.newLine === NewLineKind.CarriageReturnLineFeed ? /[^\r]\n/ : /\r\n/), "expected not to find inappropriate newlines");
+        }
+
+        function verifyBothNewLines(content: string) {
+            verifyNewLines(content, { newLine: NewLineKind.CarriageReturnLineFeed });
+            verifyNewLines(content, { newLine: NewLineKind.LineFeed });
+        }
+
+        it("should exist and respect provided compiler options", () => {
+            verifyBothNewLines(`
+                function foo() {
+                    return 2 + 2;
+                }
+            `);
+        });
+    });
+}

src/harness/unittests/moduleResolution.ts

@@ -392,7 +392,7 @@ export = C;
     });
 
     describe("Files with different casing", () => {
-        const library = createSourceFile("lib.d.ts", "", ScriptTarget.ES5);
+        let library: SourceFile;
         function test(files: Map<string>, options: CompilerOptions, currentDirectory: string, useCaseSensitiveFileNames: boolean, rootFiles: string[], diagnosticCodes: number[]): void {
             const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
             if (!useCaseSensitiveFileNames) {
@@ -406,6 +406,9 @@ export = C;
             const host: CompilerHost = {
                 getSourceFile: (fileName: string, languageVersion: ScriptTarget) => {
                     if (fileName === "lib.d.ts") {
+                        if (!library) {
+                            library = createSourceFile("lib.d.ts", "", ScriptTarget.ES5);
+                        }
                         return library;
                     }
                     const path = getCanonicalFileName(normalizePath(combinePaths(currentDirectory, fileName)));

src/harness/unittests/projectErrors.ts

@@ -57,7 +57,7 @@ namespace ts.projectSystem {
                 });
 
                 checkNumberOfProjects(projectService, { externalProjects: 1 });
-                const diags = session.executeCommand(compilerOptionsRequest).response;
+                const diags = session.executeCommand(compilerOptionsRequest).response as server.protocol.DiagnosticWithLinePosition[];
                 // only file1 exists - expect error
                 checkDiagnosticsWithLinePos(diags, ["File '/a/b/applib.ts' not found."]);
             }
@@ -65,7 +65,7 @@ namespace ts.projectSystem {
             {
                 // only file2 exists - expect error
                 checkNumberOfProjects(projectService, { externalProjects: 1 });
-                const diags = session.executeCommand(compilerOptionsRequest).response;
+                const diags = session.executeCommand(compilerOptionsRequest).response as server.protocol.DiagnosticWithLinePosition[];
                 checkDiagnosticsWithLinePos(diags, ["File '/a/b/app.ts' not found."]);
             }
 
@@ -73,7 +73,7 @@ namespace ts.projectSystem {
             {
                 // both files exist - expect no errors
                 checkNumberOfProjects(projectService, { externalProjects: 1 });
-                const diags = session.executeCommand(compilerOptionsRequest).response;
+                const diags = session.executeCommand(compilerOptionsRequest).response as server.protocol.DiagnosticWithLinePosition[];
                 checkDiagnosticsWithLinePos(diags, []);
             }
         });
@@ -103,13 +103,13 @@ namespace ts.projectSystem {
                 seq: 2,
                 arguments: { projectFileName: project.getProjectName() }
             };
-            let diags = session.executeCommand(compilerOptionsRequest).response;
+            let diags = session.executeCommand(compilerOptionsRequest).response as server.protocol.DiagnosticWithLinePosition[];
             checkDiagnosticsWithLinePos(diags, ["File '/a/b/applib.ts' not found."]);
 
             host.reloadFS([file1, file2, config, libFile]);
 
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
-            diags = session.executeCommand(compilerOptionsRequest).response;
+            diags = session.executeCommand(compilerOptionsRequest).response as server.protocol.DiagnosticWithLinePosition[];
             checkDiagnosticsWithLinePos(diags, []);
         });
 

src/harness/unittests/session.ts

@@ -16,8 +16,8 @@ namespace ts.server {
         directoryExists: () => false,
         getDirectories: () => [],
         createDirectory: noop,
-        getExecutingFilePath(): string { return void 0; },
-        getCurrentDirectory(): string { return void 0; },
+        getExecutingFilePath(): string { return ""; },
+        getCurrentDirectory(): string { return ""; },
         getEnvironmentVariable(): string { return ""; },
         readDirectory() { return []; },
         exit: noop,
@@ -315,7 +315,7 @@ namespace ts.server {
                     item: false
                 };
                 const command = "newhandle";
-                const result = {
+                const result: ts.server.HandlerResponse = {
                     response: respBody,
                     responseRequired: true
                 };
@@ -332,7 +332,7 @@ namespace ts.server {
                 const respBody = {
                     item: false
                 };
-                const resp = {
+                const resp: ts.server.HandlerResponse = {
                     response: respBody,
                     responseRequired: true
                 };
@@ -372,7 +372,7 @@ namespace ts.server {
                 };
                 const command = "test";
 
-                session.output(body, command);
+                session.output(body, command, /*reqSeq*/ 0);
 
                 expect(lastSent).to.deep.equal({
                     seq: 0,
@@ -386,6 +386,61 @@ namespace ts.server {
         });
     });
 
+    describe("exceptions", () => {
+        const command = "testhandler";
+        class TestSession extends Session {
+            lastSent: protocol.Message;
+            private exceptionRaisingHandler(_request: protocol.Request): { response?: any, responseRequired: boolean } {
+                f1();
+                return;
+                function f1() {
+                    throw new Error("myMessage");
+                }
+            }
+
+            constructor() {
+                super({
+                    host: mockHost,
+                    cancellationToken: nullCancellationToken,
+                    useSingleInferredProject: false,
+                    useInferredProjectPerProjectRoot: false,
+                    typingsInstaller: undefined,
+                    byteLength: Utils.byteLength,
+                    hrtime: process.hrtime,
+                    logger: projectSystem.nullLogger,
+                    canUseEvents: true
+                });
+                this.addProtocolHandler(command, this.exceptionRaisingHandler);
+            }
+            send(msg: protocol.Message) {
+                this.lastSent = msg;
+            }
+        }
+
+        it("raised in a protocol handler generate an event", () => {
+
+            const session = new TestSession();
+
+            const request = {
+                command,
+                seq: 0,
+                type: "request"
+            };
+
+            session.onMessage(JSON.stringify(request));
+            const lastSent = session.lastSent as protocol.Response;
+
+            expect(lastSent).to.contain({
+                seq: 0,
+                type: "response",
+                command,
+                success: false
+            });
+
+            expect(lastSent.message).has.string("myMessage").and.has.string("f1");
+        });
+    });
+
     describe("how Session is extendable via subclassing", () => {
         class TestSession extends Session {
             lastSent: protocol.Message;
@@ -420,7 +475,7 @@ namespace ts.server {
             };
             const command = "test";
 
-            session.output(body, command);
+            session.output(body, command, /*reqSeq*/ 0);
 
             expect(session.lastSent).to.deep.equal({
                 seq: 0,
@@ -487,7 +542,7 @@ namespace ts.server {
             handleRequest(msg: protocol.Request) {
                 let response: protocol.Response;
                 try {
-                    ({ response } = this.executeCommand(msg));
+                    response = this.executeCommand(msg).response as protocol.Response;
                 }
                 catch (e) {
                     this.output(undefined, msg.command, msg.seq, e.toString());
@@ -606,4 +661,28 @@ namespace ts.server {
             session.consumeQueue();
         });
     });
+
+    describe("helpers", () => {
+        it(getLocationInNewDocument.name, () => {
+            const text = `// blank line\nconst x = 0;`;
+            const renameLocationInOldText = text.indexOf("0");
+            const fileName = "/a.ts";
+            const edits: ts.FileTextChanges = {
+                fileName,
+                textChanges: [
+                    {
+                        span: { start: 0, length: 0 },
+                        newText: "const newLocal = 0;\n\n",
+                    },
+                    {
+                        span: { start: renameLocationInOldText, length: 1 },
+                        newText: "newLocal",
+                    },
+                ],
+            };
+            const renameLocationInNewText = renameLocationInOldText + edits.textChanges[0].newText.length;
+            const res = getLocationInNewDocument(text, fileName, renameLocationInNewText, [edits]);
+            assert.deepEqual(res, { line: 4, offset: 11 });
+        });
+    });
 }

src/harness/unittests/telemetry.ts

@@ -5,9 +5,9 @@ namespace ts.projectSystem {
     describe("project telemetry", () => {
         it("does nothing for inferred project", () => {
             const file = makeFile("/a.js");
-            const et = new EventTracker([file]);
+            const et = new TestServerEventManager([file]);
             et.service.openClientFile(file.path);
-            assert.equal(et.getEvents().length, 0);
+            et.hasZeroEvent(ts.server.ProjectInfoTelemetryEvent);
         });
 
         it("only sends an event once", () => {
@@ -15,7 +15,7 @@ namespace ts.projectSystem {
             const file2 = makeFile("/b.ts");
             const tsconfig = makeFile("/a/tsconfig.json", {});
 
-            const et = new EventTracker([file, file2, tsconfig]);
+            const et = new TestServerEventManager([file, file2, tsconfig]);
             et.service.openClientFile(file.path);
             et.assertProjectInfoTelemetryEvent({}, tsconfig.path);
 
@@ -25,12 +25,12 @@ namespace ts.projectSystem {
             et.service.openClientFile(file2.path);
             checkNumberOfProjects(et.service, { inferredProjects: 1 });
 
-            assert.equal(et.getEvents().length, 0);
+            et.hasZeroEvent(ts.server.ProjectInfoTelemetryEvent);
 
             et.service.openClientFile(file.path);
             checkNumberOfProjects(et.service, { configuredProjects: 1, inferredProjects: 1 });
 
-            assert.equal(et.getEvents().length, 0);
+            et.hasZeroEvent(ts.server.ProjectInfoTelemetryEvent);
         });
 
         it("counts files by extension", () => {
@@ -39,7 +39,7 @@ namespace ts.projectSystem {
             const compilerOptions: ts.CompilerOptions = { allowJs: true };
             const tsconfig = makeFile("/tsconfig.json", { compilerOptions, include: ["src"] });
 
-            const et = new EventTracker([...files, notIncludedFile, tsconfig]);
+            const et = new TestServerEventManager([...files, notIncludedFile, tsconfig]);
             et.service.openClientFile(files[0].path);
             et.assertProjectInfoTelemetryEvent({
                 fileStats: { ts: 2, tsx: 1, js: 1, jsx: 1, dts: 1 },
@@ -50,7 +50,7 @@ namespace ts.projectSystem {
 
         it("works with external project", () => {
             const file1 = makeFile("/a.ts");
-            const et = new EventTracker([file1]);
+            const et = new TestServerEventManager([file1]);
             const compilerOptions: ts.server.protocol.CompilerOptions = { strict: true };
 
             const projectFileName = "/hunter2/foo.csproj";
@@ -148,7 +148,7 @@ namespace ts.projectSystem {
             (compilerOptions as any).unknownCompilerOption = "hunter2"; // These are always ignored.
             const tsconfig = makeFile("/tsconfig.json", { compilerOptions, files: ["/a.ts"] });
 
-            const et = new EventTracker([file, tsconfig]);
+            const et = new TestServerEventManager([file, tsconfig]);
             et.service.openClientFile(file.path);
 
             et.assertProjectInfoTelemetryEvent({
@@ -168,7 +168,7 @@ namespace ts.projectSystem {
                 compileOnSave: true,
             });
 
-            const et = new EventTracker([tsconfig, file]);
+            const et = new TestServerEventManager([tsconfig, file]);
             et.service.openClientFile(file.path);
             et.assertProjectInfoTelemetryEvent({
                 extends: true,
@@ -198,7 +198,7 @@ namespace ts.projectSystem {
                     exclude: [],
                 },
             });
-            const et = new EventTracker([jsconfig, file]);
+            const et = new TestServerEventManager([jsconfig, file]);
             et.service.openClientFile(file.path);
             et.assertProjectInfoTelemetryEvent({
                 projectId: Harness.mockHash("/jsconfig.json"),
@@ -216,10 +216,10 @@ namespace ts.projectSystem {
         it("detects whether language service was disabled", () => {
             const file = makeFile("/a.js");
             const tsconfig = makeFile("/jsconfig.json", {});
-            const et = new EventTracker([tsconfig, file]);
+            const et = new TestServerEventManager([tsconfig, file]);
             et.host.getFileSize = () => server.maxProgramSizeForNonTsFiles + 1;
             et.service.openClientFile(file.path);
-            et.getEvent<server.ProjectLanguageServiceStateEvent>(server.ProjectLanguageServiceStateEvent, /*mayBeMore*/ true);
+            et.getEvent<server.ProjectLanguageServiceStateEvent>(server.ProjectLanguageServiceStateEvent);
             et.assertProjectInfoTelemetryEvent({
                 projectId: Harness.mockHash("/jsconfig.json"),
                 fileStats: fileStats({ js: 1 }),
@@ -235,63 +235,7 @@ namespace ts.projectSystem {
         });
     });
 
-    class EventTracker {
-        private events: server.ProjectServiceEvent[] = [];
-        readonly service: TestProjectService;
-        readonly host: projectSystem.TestServerHost;
-
-        constructor(files: projectSystem.FileOrFolder[]) {
-            this.host = createServerHost(files);
-            this.service = createProjectService(this.host, {
-                eventHandler: event => {
-                    this.events.push(event);
-                },
-            });
-        }
-
-        getEvents(): ReadonlyArray<server.ProjectServiceEvent> {
-            const events = this.events;
-            this.events = [];
-            return events;
-        }
-
-        assertProjectInfoTelemetryEvent(partial: Partial<server.ProjectInfoTelemetryEventData>, configFile?: string): void {
-            assert.deepEqual(this.getEvent<server.ProjectInfoTelemetryEvent>(ts.server.ProjectInfoTelemetryEvent), {
-                projectId: Harness.mockHash(configFile || "/tsconfig.json"),
-                fileStats: fileStats({ ts: 1 }),
-                compilerOptions: {},
-                extends: false,
-                files: false,
-                include: false,
-                exclude: false,
-                compileOnSave: false,
-                typeAcquisition: {
-                    enable: false,
-                    exclude: false,
-                    include: false,
-                },
-                configFileName: "tsconfig.json",
-                projectType: "configured",
-                languageServiceEnabled: true,
-                version: ts.version,
-                ...partial,
-            });
-        }
-
-        getEvent<T extends server.ProjectServiceEvent>(eventName: T["eventName"], mayBeMore = false): T["data"] {
-            if (mayBeMore) { assert(this.events.length !== 0); }
-            else { assert.equal(this.events.length, 1); }
-            const event = this.events.shift();
-            assert.equal(event.eventName, eventName);
-            return event.data;
-        }
-    }
-
     function makeFile(path: string, content: {} = ""): projectSystem.FileOrFolder {
         return { path, content: isString(content) ? "" : JSON.stringify(content) };
     }
-
-    function fileStats(nonZeroStats: Partial<server.FileStats>): server.FileStats {
-        return { ts: 0, tsx: 0, dts: 0, js: 0, jsx: 0, ...nonZeroStats };
-    }
 }

src/harness/unittests/tscWatchMode.ts

@@ -80,6 +80,92 @@ namespace ts.tscWatch {
         checkOutputDoesNotContain(host, expectedNonAffectedFiles);
     }
 
+    function checkOutputErrors(host: WatchedSystem, errors?: ReadonlyArray<Diagnostic>, isInitial?: true, skipWaiting?: true) {
+        const outputs = host.getOutput();
+        const expectedOutputCount = (isInitial ? 0 : 1) + (errors ? errors.length : 0) + (skipWaiting ? 0 : 1);
+        assert.equal(outputs.length, expectedOutputCount, "Outputs = " + outputs.toString());
+        let index = 0;
+        if (!isInitial) {
+            assertWatchDiagnosticAt(host, index, Diagnostics.File_change_detected_Starting_incremental_compilation);
+            index++;
+        }
+        forEach(errors, error => {
+            assertDiagnosticAt(host, index, error);
+            index++;
+        });
+        if (!skipWaiting) {
+            assertWatchDiagnosticAt(host, index, Diagnostics.Compilation_complete_Watching_for_file_changes);
+        }
+        host.clearOutput();
+    }
+
+    function assertDiagnosticAt(host: WatchedSystem, outputAt: number, diagnostic: Diagnostic) {
+        const output = host.getOutput()[outputAt];
+        assert.equal(output, formatDiagnostic(diagnostic, host), "outputs[" + outputAt + "] is " + output);
+    }
+
+    function assertWatchDiagnosticAt(host: WatchedSystem, outputAt: number, diagnosticMessage: DiagnosticMessage) {
+        const output = host.getOutput()[outputAt];
+        assert.isTrue(endsWith(output, getWatchDiagnosticWithoutDate(host, diagnosticMessage)), "outputs[" + outputAt + "] is " + output);
+    }
+
+    function getWatchDiagnosticWithoutDate(host: WatchedSystem, diagnosticMessage: DiagnosticMessage) {
+        return ` - ${flattenDiagnosticMessageText(getLocaleSpecificMessage(diagnosticMessage), host.newLine)}${host.newLine + host.newLine + host.newLine}`;
+    }
+
+    function getDiagnosticOfFileFrom(file: SourceFile, text: string, start: number, length: number, message: DiagnosticMessage): Diagnostic {
+        return {
+            file,
+            start,
+            length,
+
+            messageText: text,
+            category: message.category,
+            code: message.code,
+        };
+    }
+
+    function getDiagnosticWithoutFile(message: DiagnosticMessage, ..._args: (string | number)[]): Diagnostic {
+        let text = getLocaleSpecificMessage(message);
+
+        if (arguments.length > 1) {
+            text = formatStringFromArgs(text, arguments, 1);
+        }
+
+        return getDiagnosticOfFileFrom(/*file*/ undefined, text, /*start*/ undefined, /*length*/ undefined, message);
+    }
+
+    function getDiagnosticOfFile(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ..._args: (string | number)[]): Diagnostic {
+        let text = getLocaleSpecificMessage(message);
+
+        if (arguments.length > 4) {
+            text = formatStringFromArgs(text, arguments, 4);
+        }
+
+        return getDiagnosticOfFileFrom(file, text, start, length, message);
+    }
+
+    function getUnknownCompilerOption(program: Program, configFile: FileOrFolder, option: string) {
+        const quotedOption = `"${option}"`;
+        return getDiagnosticOfFile(program.getCompilerOptions().configFile, configFile.content.indexOf(quotedOption), quotedOption.length, Diagnostics.Unknown_compiler_option_0, option);
+    }
+
+    function getDiagnosticOfFileFromProgram(program: Program, filePath: string, start: number, length: number, message: DiagnosticMessage, ..._args: (string | number)[]): Diagnostic {
+        let text = getLocaleSpecificMessage(message);
+
+        if (arguments.length > 5) {
+            text = formatStringFromArgs(text, arguments, 5);
+        }
+
+        return getDiagnosticOfFileFrom(program.getSourceFileByPath(toPath(filePath, program.getCurrentDirectory(), s => s.toLowerCase())),
+            text, start, length, message);
+    }
+
+    function getDiagnosticModuleNotFoundOfFile(program: Program, file: FileOrFolder, moduleName: string) {
+        const quotedModuleName = `"${moduleName}"`;
+        return getDiagnosticOfFileFromProgram(program, file.path, file.content.indexOf(quotedModuleName), quotedModuleName.length, Diagnostics.Cannot_find_module_0, moduleName);
+    }
+
     describe("tsc-watch program updates", () => {
         const commonFile1: FileOrFolder = {
             path: "/a/b/commonFile1.ts",
@@ -168,7 +254,7 @@ namespace ts.tscWatch {
             checkProgramRootFiles(watch(), [file1.path, file2.path]);
             checkWatchedFiles(host, [configFile.path, file1.path, file2.path, libFile.path]);
             const configDir = getDirectoryPath(configFile.path);
-            checkWatchedDirectories(host, projectSystem.getTypeRootsFromLocation(configDir).concat(configDir), /*recursive*/ true);
+            checkWatchedDirectories(host, [configDir, combinePaths(configDir, projectSystem.nodeModulesAtTypes)], /*recursive*/ true);
         });
 
         // TODO: if watching for config file creation
@@ -183,7 +269,7 @@ namespace ts.tscWatch {
             const host = createWatchedSystem([commonFile1, libFile, configFile]);
             const watch = createWatchModeWithConfigFile(configFile.path, host);
             const configDir = getDirectoryPath(configFile.path);
-            checkWatchedDirectories(host, projectSystem.getTypeRootsFromLocation(configDir).concat(configDir), /*recursive*/ true);
+            checkWatchedDirectories(host, [configDir, combinePaths(configDir, projectSystem.nodeModulesAtTypes)], /*recursive*/ true);
 
             checkProgramRootFiles(watch(), [commonFile1.path]);
 
@@ -233,9 +319,10 @@ namespace ts.tscWatch {
         });
 
         it("handles the missing files - that were added to program because they were added with ///<ref", () => {
+            const commonFile2Name = "commonFile2.ts";
             const file1: FileOrFolder = {
                 path: "/a/b/commonFile1.ts",
-                content: `/// <reference path="commonFile2.ts"/>
+                content: `/// <reference path="${commonFile2Name}"/>
                     let x = y`
             };
             const host = createWatchedSystem([file1, libFile]);
@@ -243,18 +330,16 @@ namespace ts.tscWatch {
 
             checkProgramRootFiles(watch(), [file1.path]);
             checkProgramActualFiles(watch(), [file1.path, libFile.path]);
-            const errors = [
-                `a/b/commonFile1.ts(1,22): error TS6053: File '${commonFile2.path}' not found.${host.newLine}`,
-                `a/b/commonFile1.ts(2,29): error TS2304: Cannot find name 'y'.${host.newLine}`
-            ];
-            checkOutputContains(host, errors);
-            host.clearOutput();
+            checkOutputErrors(host, [
+                getDiagnosticOfFileFromProgram(watch(), file1.path, file1.content.indexOf(commonFile2Name), commonFile2Name.length, Diagnostics.File_0_not_found, commonFile2.path),
+                getDiagnosticOfFileFromProgram(watch(), file1.path, file1.content.indexOf("y"), 1, Diagnostics.Cannot_find_name_0, "y")
+            ], /*isInitial*/ true);
 
             host.reloadFS([file1, commonFile2, libFile]);
             host.runQueuedTimeoutCallbacks();
             checkProgramRootFiles(watch(), [file1.path]);
             checkProgramActualFiles(watch(), [file1.path, libFile.path, commonFile2.path]);
-            checkOutputDoesNotContain(host, errors);
+            checkOutputErrors(host);
         });
 
         it("should reflect change in config file", () => {
@@ -578,17 +663,19 @@ namespace ts.tscWatch {
                 path: "/a/b/tsconfig.json",
                 content: JSON.stringify({ compilerOptions: {} })
             };
-            const host = createWatchedSystem([file1, file2, config]);
+            const host = createWatchedSystem([file1, file2, libFile, config]);
             const watch = createWatchModeWithConfigFile(config.path, host);
 
-            checkProgramActualFiles(watch(), [file1.path, file2.path]);
+            checkProgramActualFiles(watch(), [file1.path, file2.path, libFile.path]);
+            checkOutputErrors(host, emptyArray, /*isInitial*/ true);
 
-            host.clearOutput();
-            host.reloadFS([file1, file2]);
+            host.reloadFS([file1, file2, libFile]);
             host.checkTimeoutQueueLengthAndRun(1);
 
             assert.equal(host.exitCode, ExitStatus.DiagnosticsPresent_OutputsSkipped);
-            checkOutputContains(host, [`error TS6053: File '${config.path}' not found.${host.newLine}`]);
+            checkOutputErrors(host, [
+                getDiagnosticWithoutFile(Diagnostics.File_0_not_found, config.path)
+            ], /*isInitial*/ undefined, /*skipWaiting*/ true);
         });
 
         it("Proper errors: document is not contained in project", () => {
@@ -687,25 +774,25 @@ namespace ts.tscWatch {
             };
             const file1 = {
                 path: "/a/b/file1.ts",
-                content: "import * as T from './moduleFile'; T.bar();"
+                content: 'import * as T from "./moduleFile"; T.bar();'
             };
             const host = createWatchedSystem([moduleFile, file1, libFile]);
-            createWatchModeWithoutConfigFile([file1.path], host);
-            const error = "a/b/file1.ts(1,20): error TS2307: Cannot find module \'./moduleFile\'.\n";
-            checkOutputDoesNotContain(host, [error]);
+            const watch = createWatchModeWithoutConfigFile([file1.path], host);
+            checkOutputErrors(host, emptyArray, /*isInitial*/ true);
 
             const moduleFileOldPath = moduleFile.path;
             const moduleFileNewPath = "/a/b/moduleFile1.ts";
             moduleFile.path = moduleFileNewPath;
             host.reloadFS([moduleFile, file1, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputContains(host, [error]);
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), file1, "./moduleFile")
+            ]);
 
-            host.clearOutput();
             moduleFile.path = moduleFileOldPath;
             host.reloadFS([moduleFile, file1, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputDoesNotContain(host, [error]);
+            checkOutputErrors(host);
         });
 
         it("rename a module file and rename back should restore the states for configured projects", () => {
@@ -715,31 +802,29 @@ namespace ts.tscWatch {
             };
             const file1 = {
                 path: "/a/b/file1.ts",
-                content: "import * as T from './moduleFile'; T.bar();"
+                content: 'import * as T from "./moduleFile"; T.bar();'
             };
             const configFile = {
                 path: "/a/b/tsconfig.json",
                 content: `{}`
             };
             const host = createWatchedSystem([moduleFile, file1, configFile, libFile]);
-            createWatchModeWithConfigFile(configFile.path, host);
-
-            const error = "a/b/file1.ts(1,20): error TS2307: Cannot find module \'./moduleFile\'.\n";
-            checkOutputDoesNotContain(host, [error]);
+            const watch = createWatchModeWithConfigFile(configFile.path, host);
+            checkOutputErrors(host, emptyArray, /*isInitial*/ true);
 
             const moduleFileOldPath = moduleFile.path;
             const moduleFileNewPath = "/a/b/moduleFile1.ts";
             moduleFile.path = moduleFileNewPath;
-            host.clearOutput();
             host.reloadFS([moduleFile, file1, configFile, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputContains(host, [error]);
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), file1, "./moduleFile")
+            ]);
 
-            host.clearOutput();
             moduleFile.path = moduleFileOldPath;
             host.reloadFS([moduleFile, file1, configFile, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputDoesNotContain(host, [error]);
+            checkOutputErrors(host);
         });
 
         it("types should load from config file path if config exists", () => {
@@ -771,18 +856,18 @@ namespace ts.tscWatch {
             };
             const file1 = {
                 path: "/a/b/file1.ts",
-                content: "import * as T from './moduleFile'; T.bar();"
+                content: 'import * as T from "./moduleFile"; T.bar();'
             };
             const host = createWatchedSystem([file1, libFile]);
-            createWatchModeWithoutConfigFile([file1.path], host);
+            const watch = createWatchModeWithoutConfigFile([file1.path], host);
 
-            const error = `a/b/file1.ts(1,20): error TS2307: Cannot find module \'./moduleFile\'.${host.newLine}`;
-            checkOutputContains(host, [error]);
-            host.clearOutput();
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), file1, "./moduleFile")
+            ], /*isInitial*/ true);
 
             host.reloadFS([file1, moduleFile, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputDoesNotContain(host, [error]);
+            checkOutputErrors(host);
         });
 
         it("Configure file diagnostics events are generated when the config file has errors", () => {
@@ -801,14 +886,14 @@ namespace ts.tscWatch {
             };
 
             const host = createWatchedSystem([file, configFile, libFile]);
-            createWatchModeWithConfigFile(configFile.path, host);
-            checkOutputContains(host, [
-                `a/b/tsconfig.json(3,29): error TS5023: Unknown compiler option \'foo\'.${host.newLine}`,
-                `a/b/tsconfig.json(4,29): error TS5023: Unknown compiler option \'allowJS\'.${host.newLine}`
-            ]);
+            const watch = createWatchModeWithConfigFile(configFile.path, host);
+            checkOutputErrors(host, [
+                getUnknownCompilerOption(watch(), configFile, "foo"),
+                getUnknownCompilerOption(watch(), configFile, "allowJS")
+            ], /*isInitial*/ true);
         });
 
-        it("Configure file diagnostics events are generated when the config file doesn't have errors", () => {
+        it("If config file doesnt have errors, they are not reported", () => {
             const file = {
                 path: "/a/b/app.ts",
                 content: "let x = 10"
@@ -822,13 +907,10 @@ namespace ts.tscWatch {
 
             const host = createWatchedSystem([file, configFile, libFile]);
             createWatchModeWithConfigFile(configFile.path, host);
-            checkOutputDoesNotContain(host, [
-                `a/b/tsconfig.json(3,29): error TS5023: Unknown compiler option \'foo\'.${host.newLine}`,
-                `a/b/tsconfig.json(4,29): error TS5023: Unknown compiler option \'allowJS\'.${host.newLine}`
-            ]);
+            checkOutputErrors(host, emptyArray, /*isInitial*/ true);
         });
 
-        it("Configure file diagnostics events are generated when the config file changes", () => {
+        it("Reports errors when the config file changes", () => {
             const file = {
                 path: "/a/b/app.ts",
                 content: "let x = 10"
@@ -841,9 +923,8 @@ namespace ts.tscWatch {
             };
 
             const host = createWatchedSystem([file, configFile, libFile]);
-            createWatchModeWithConfigFile(configFile.path, host);
-            const error = `a/b/tsconfig.json(3,25): error TS5023: Unknown compiler option 'haha'.${host.newLine}`;
-            checkOutputDoesNotContain(host, [error]);
+            const watch = createWatchModeWithConfigFile(configFile.path, host);
+            checkOutputErrors(host, emptyArray, /*isInitial*/ true);
 
             configFile.content = `{
                     "compilerOptions": {
@@ -852,15 +933,16 @@ namespace ts.tscWatch {
                 }`;
             host.reloadFS([file, configFile, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputContains(host, [error]);
+            checkOutputErrors(host, [
+                getUnknownCompilerOption(watch(), configFile, "haha")
+            ]);
 
-            host.clearOutput();
             configFile.content = `{
                     "compilerOptions": {}
                 }`;
             host.reloadFS([file, configFile, libFile]);
             host.runQueuedTimeoutCallbacks();
-            checkOutputDoesNotContain(host, [error]);
+            checkOutputErrors(host);
         });
 
         it("non-existing directories listed in config file input array should be tolerated without crashing the server", () => {
@@ -935,29 +1017,28 @@ namespace ts.tscWatch {
                 }`;
             const configFileContentWithComment = configFileContentBeforeComment + configFileContentComment + configFileContentAfterComment;
             const configFileContentWithoutCommentLine = configFileContentBeforeComment + configFileContentAfterComment;
-
-            const line = 5;
-            const errors = (line: number) => [
-                `a/b/tsconfig.json(${line},25): error TS5053: Option \'allowJs\' cannot be specified with option \'declaration\'.\n`,
-                `a/b/tsconfig.json(${line + 1},25): error TS5053: Option \'allowJs\' cannot be specified with option \'declaration\'.\n`
-            ];
-
             const configFile = {
                 path: "/a/b/tsconfig.json",
                 content: configFileContentWithComment
             };
 
-            const host = createWatchedSystem([file, libFile, configFile]);
-            createWatchModeWithConfigFile(configFile.path, host);
-            checkOutputContains(host, errors(line));
-            checkOutputDoesNotContain(host, errors(line - 2));
-            host.clearOutput();
+            const files = [file, libFile, configFile];
+            const host = createWatchedSystem(files);
+            const watch = createWatchModeWithConfigFile(configFile.path, host);
+            const errors = () => [
+                getDiagnosticOfFile(watch().getCompilerOptions().configFile, configFile.content.indexOf('"allowJs"'), '"allowJs"'.length, Diagnostics.Option_0_cannot_be_specified_with_option_1, "allowJs", "declaration"),
+                getDiagnosticOfFile(watch().getCompilerOptions().configFile, configFile.content.indexOf('"declaration"'), '"declaration"'.length, Diagnostics.Option_0_cannot_be_specified_with_option_1, "allowJs", "declaration")
+            ];
+            const intialErrors = errors();
+            checkOutputErrors(host, intialErrors, /*isInitial*/ true);
 
             configFile.content = configFileContentWithoutCommentLine;
-            host.reloadFS([file, configFile]);
+            host.reloadFS(files);
             host.runQueuedTimeoutCallbacks();
-            checkOutputContains(host, errors(line - 2));
-            checkOutputDoesNotContain(host, errors(line));
+            const nowErrors = errors();
+            checkOutputErrors(host, nowErrors);
+            assert.equal(nowErrors[0].start, intialErrors[0].start - configFileContentComment.length);
+            assert.equal(nowErrors[1].start, intialErrors[1].start - configFileContentComment.length);
         });
     });
 
@@ -1024,6 +1105,64 @@ namespace ts.tscWatch {
             const outJs = "/a/out.js";
             createWatchForOut(/*out*/ undefined, outJs);
         });
+
+        function verifyFilesEmittedOnce(useOutFile: boolean) {
+            const file1: FileOrFolder = {
+                path: "/a/b/output/AnotherDependency/file1.d.ts",
+                content: "declare namespace Common.SomeComponent.DynamicMenu { enum Z { Full = 0,  Min = 1, Average = 2, } }"
+            };
+            const file2: FileOrFolder = {
+                path: "/a/b/dependencies/file2.d.ts",
+                content: "declare namespace Dependencies.SomeComponent { export class SomeClass { version: string; } }"
+            };
+            const file3: FileOrFolder = {
+                path: "/a/b/project/src/main.ts",
+                content: "namespace Main { export function fooBar() {} }"
+            };
+            const file4: FileOrFolder = {
+                path: "/a/b/project/src/main2.ts",
+                content: "namespace main.file4 { import DynamicMenu = Common.SomeComponent.DynamicMenu; export function foo(a: DynamicMenu.z) {  } }"
+            };
+            const configFile: FileOrFolder = {
+                path: "/a/b/project/tsconfig.json",
+                content: JSON.stringify({
+                    compilerOptions: useOutFile ?
+                        { outFile: "../output/common.js", target: "es5" } :
+                        { outDir: "../output", target: "es5" },
+                    files: [file1.path, file2.path, file3.path, file4.path]
+                })
+            };
+            const files = [file1, file2, file3, file4];
+            const allfiles = files.concat(configFile);
+            const host = createWatchedSystem(allfiles);
+            const originalWriteFile = host.writeFile.bind(host);
+            const mapOfFilesWritten = createMap<number>();
+            host.writeFile = (p: string, content: string) => {
+                const count = mapOfFilesWritten.get(p);
+                mapOfFilesWritten.set(p, count ? count + 1 : 1);
+                return originalWriteFile(p, content);
+            };
+            createWatchModeWithConfigFile(configFile.path, host);
+            if (useOutFile) {
+                // Only out file
+                assert.equal(mapOfFilesWritten.size, 1);
+            }
+            else {
+                // main.js and main2.js
+                assert.equal(mapOfFilesWritten.size, 2);
+            }
+            mapOfFilesWritten.forEach((value, key) => {
+                assert.equal(value, 1, "Key: " + key);
+            });
+        }
+
+        it("with --outFile and multiple declaration files in the program", () => {
+            verifyFilesEmittedOnce(/*useOutFile*/ true);
+        });
+
+        it("without --outFile and multiple declaration files in the program", () => {
+            verifyFilesEmittedOnce(/*useOutFile*/ false);
+        });
     });
 
     describe("tsc-watch emit for configured projects", () => {
@@ -1485,23 +1624,20 @@ namespace ts.tscWatch {
                 path: "/a/d/f0.ts",
                 content: `import {x} from "f1"`
             };
-
             const imported = {
                 path: "/a/f1.ts",
                 content: `foo()`
             };
 
-            const f1IsNotModule = `a/d/f0.ts(1,17): error TS2306: File '${imported.path}' is not a module.\n`;
-            const cannotFindFoo = `a/f1.ts(1,1): error TS2304: Cannot find name 'foo'.\n`;
-            const cannotAssignValue = "a/d/f0.ts(2,21): error TS2322: Type '1' is not assignable to type 'string'.\n";
-
             const files = [root, imported, libFile];
             const host = createWatchedSystem(files);
-            createWatchModeWithoutConfigFile([root.path], host, { module: ModuleKind.AMD });
+            const watch = createWatchModeWithoutConfigFile([root.path], host, { module: ModuleKind.AMD });
+
+            const f1IsNotModule = getDiagnosticOfFileFromProgram(watch(), root.path, root.content.indexOf('"f1"'), '"f1"'.length, Diagnostics.File_0_is_not_a_module, imported.path);
+            const cannotFindFoo = getDiagnosticOfFileFromProgram(watch(), imported.path, imported.content.indexOf("foo"), "foo".length, Diagnostics.Cannot_find_name_0, "foo");
 
             // ensure that imported file was found
-            checkOutputContains(host, [f1IsNotModule, cannotFindFoo]);
-            host.clearOutput();
+            checkOutputErrors(host, [f1IsNotModule, cannotFindFoo], /*isInitial*/ true);
 
             const originalFileExists = host.fileExists;
             {
@@ -1517,8 +1653,11 @@ namespace ts.tscWatch {
                 host.runQueuedTimeoutCallbacks();
 
                 // ensure file has correct number of errors after edit
-                checkOutputContains(host, [f1IsNotModule, cannotAssignValue]);
-                host.clearOutput();
+                checkOutputErrors(host, [
+                    f1IsNotModule,
+                    getDiagnosticOfFileFromProgram(watch(), root.path, newContent.indexOf("var x") + "var ".length, "x".length, Diagnostics.Type_0_is_not_assignable_to_type_1, 1, "string"),
+                    cannotFindFoo
+                ]);
             }
             {
                 let fileExistsIsCalled = false;
@@ -1534,13 +1673,13 @@ namespace ts.tscWatch {
                 root.content = `import {x} from "f2"`;
                 host.reloadFS(files);
 
-                    // trigger synchronization to make sure that LSHost will try to find 'f2' module on disk
-                    host.runQueuedTimeoutCallbacks();
+                // trigger synchronization to make sure that LSHost will try to find 'f2' module on disk
+                host.runQueuedTimeoutCallbacks();
 
-                    // ensure file has correct number of errors after edit
-                    const cannotFindModuleF2 = `a/d/f0.ts(1,17): error TS2307: Cannot find module 'f2'.\n`;
-                    checkOutputContains(host, [cannotFindModuleF2]);
-                    host.clearOutput();
+                // ensure file has correct number of errors after edit
+                checkOutputErrors(host, [
+                    getDiagnosticModuleNotFoundOfFile(watch(), root, "f2")
+                ]);
 
                 assert.isTrue(fileExistsIsCalled);
             }
@@ -1561,7 +1700,7 @@ namespace ts.tscWatch {
                 host.reloadFS(files);
                 host.runQueuedTimeoutCallbacks();
 
-                checkOutputContains(host, [f1IsNotModule, cannotFindFoo]);
+                checkOutputErrors(host, [f1IsNotModule, cannotFindFoo]);
                 assert.isTrue(fileExistsCalled);
             }
         });
@@ -1593,12 +1732,12 @@ namespace ts.tscWatch {
                 return originalFileExists.call(host, fileName);
             };
 
-            createWatchModeWithoutConfigFile([root.path], host, { module: ModuleKind.AMD });
+            const watch = createWatchModeWithoutConfigFile([root.path], host, { module: ModuleKind.AMD });
 
-            const barNotFound = `a/foo.ts(1,17): error TS2307: Cannot find module 'bar'.\n`;
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called");
-            checkOutputContains(host, [barNotFound]);
-            host.clearOutput();
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), root, "bar")
+            ], /*isInitial*/ true);
 
             fileExistsCalledForBar = false;
             root.content = `import {y} from "bar"`;
@@ -1606,7 +1745,7 @@ namespace ts.tscWatch {
 
             host.runQueuedTimeoutCallbacks();
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called.");
-            checkOutputDoesNotContain(host, [barNotFound]);
+            checkOutputErrors(host);
         });
 
         it("should compile correctly when resolved module goes missing and then comes back (module is not part of the root)", () => {
@@ -1617,7 +1756,7 @@ namespace ts.tscWatch {
 
             const imported = {
                 path: `/a/bar.d.ts`,
-                content: `export const y = 1;`
+                content: `export const y = 1;export const x = 10;`
             };
 
             const files = [root, libFile];
@@ -1635,25 +1774,147 @@ namespace ts.tscWatch {
                 return originalFileExists.call(host, fileName);
             };
 
-            createWatchModeWithoutConfigFile([root.path], host, { module: ModuleKind.AMD });
+            const watch = createWatchModeWithoutConfigFile([root.path], host, { module: ModuleKind.AMD });
 
-            const barNotFound = `a/foo.ts(1,17): error TS2307: Cannot find module 'bar'.\n`;
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called");
-            checkOutputDoesNotContain(host, [barNotFound]);
-            host.clearOutput();
+            checkOutputErrors(host, emptyArray, /*isInitial*/ true);
 
             fileExistsCalledForBar = false;
             host.reloadFS(files);
             host.runQueuedTimeoutCallbacks();
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called.");
-            checkOutputContains(host, [barNotFound]);
-            host.clearOutput();
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), root, "bar")
+            ]);
 
             fileExistsCalledForBar = false;
             host.reloadFS(filesWithImported);
             host.checkTimeoutQueueLengthAndRun(1);
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called.");
-            checkOutputDoesNotContain(host, [barNotFound]);
+            checkOutputErrors(host);
+        });
+
+        it("works when module resolution changes to ambient module", () => {
+            const root = {
+                path: "/a/b/foo.ts",
+                content: `import * as fs from "fs";`
+            };
+
+            const packageJson = {
+                path: "/a/b/node_modules/@types/node/package.json",
+                content: `
+{
+  "main": ""
+}
+`
+            };
+
+            const nodeType = {
+                path: "/a/b/node_modules/@types/node/index.d.ts",
+                content: `
+declare module "fs" {
+    export interface Stats {
+        isFile(): boolean;
+    }
+}`
+            };
+
+            const files = [root, libFile];
+            const filesWithNodeType = files.concat(packageJson, nodeType);
+            const host = createWatchedSystem(files, { currentDirectory: "/a/b" });
+
+            const watch = createWatchModeWithoutConfigFile([root.path], host, { });
+
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), root, "fs")
+            ], /*isInitial*/ true);
+
+            host.reloadFS(filesWithNodeType);
+            host.runQueuedTimeoutCallbacks();
+            checkOutputErrors(host);
+        });
+
+        it("works when included file with ambient module changes", () => {
+            const root = {
+                path: "/a/b/foo.ts",
+                content: `
+import * as fs from "fs";
+import * as u from "url";
+`
+            };
+
+            const file = {
+                path: "/a/b/bar.d.ts",
+                content: `
+declare module "url" {
+    export interface Url {
+        href?: string;
+    }
+}
+`
+            };
+
+            const fileContentWithFS = `
+declare module "fs" {
+    export interface Stats {
+        isFile(): boolean;
+    }
+}
+`;
+
+            const files = [root, file, libFile];
+            const host = createWatchedSystem(files, { currentDirectory: "/a/b" });
+
+            const watch = createWatchModeWithoutConfigFile([root.path, file.path], host, {});
+
+            checkOutputErrors(host, [
+                getDiagnosticModuleNotFoundOfFile(watch(), root, "fs")
+            ], /*isInitial*/ true);
+
+            file.content += fileContentWithFS;
+            host.reloadFS(files);
+            host.runQueuedTimeoutCallbacks();
+            checkOutputErrors(host);
+        });
+    });
+
+    describe("tsc-watch with when module emit is specified as node", () => {
+        it("when instead of filechanged recursive directory watcher is invoked", () => {
+            const configFile: FileOrFolder = {
+                path: "/a/rootFolder/project/tsconfig.json",
+                content: JSON.stringify({
+                    "compilerOptions": {
+                        "module": "none",
+                        "allowJs": true,
+                        "outDir": "Static/scripts/"
+                    },
+                    "include": [
+                        "Scripts/**/*"
+                    ],
+                })
+            };
+            const outputFolder = "/a/rootFolder/project/Static/scripts/";
+            const file1: FileOrFolder = {
+                path: "/a/rootFolder/project/Scripts/TypeScript.ts",
+                content: "var z = 10;"
+            };
+            const file2: FileOrFolder = {
+                path: "/a/rootFolder/project/Scripts/Javascript.js",
+                content: "var zz = 10;"
+            };
+            const files = [configFile, file1, file2, libFile];
+            const host = createWatchedSystem(files);
+            const watch = createWatchModeWithConfigFile(configFile.path, host);
+
+            checkProgramActualFiles(watch(), mapDefined(files, f => f === configFile ? undefined : f.path));
+            file1.content = "var zz30 = 100;";
+            host.reloadFS(files, /*invokeDirectoryWatcherInsteadOfFileChanged*/ true);
+            host.runQueuedTimeoutCallbacks();
+
+            checkProgramActualFiles(watch(), mapDefined(files, f => f === configFile ? undefined : f.path));
+            const outputFile1 = changeExtension((outputFolder + getBaseFileName(file1.path)), ".js");
+            assert.isTrue(host.fileExists(outputFile1));
+            assert.equal(host.readFile(outputFile1), file1.content + host.newLine);
         });
     });
 }

src/harness/unittests/typingsInstaller.ts

@@ -4,6 +4,8 @@
 
 namespace ts.projectSystem {
     import TI = server.typingsInstaller;
+    import validatePackageName = JsTyping.validatePackageName;
+    import PackageNameValidationResult = JsTyping.PackageNameValidationResult;
 
     interface InstallerParams {
         globalTypingsCacheLocation?: string;
@@ -266,7 +268,7 @@ namespace ts.projectSystem {
             };
             const host = createServerHost([file1]);
             let enqueueIsCalled = false;
-            const installer = new (class extends Installer {
+            const installer: Installer = new (class extends Installer {
                 constructor() {
                     super(host, { typesRegistry: createTypesRegistry("jquery") });
                 }
@@ -983,21 +985,21 @@ namespace ts.projectSystem {
             for (let i = 0; i < 8; i++) {
                 packageName += packageName;
             }
-            assert.equal(TI.validatePackageName(packageName), TI.PackageNameValidationResult.NameTooLong);
+            assert.equal(validatePackageName(packageName), PackageNameValidationResult.NameTooLong);
         });
         it("name cannot start with dot", () => {
-            assert.equal(TI.validatePackageName(".foo"), TI.PackageNameValidationResult.NameStartsWithDot);
+            assert.equal(validatePackageName(".foo"), PackageNameValidationResult.NameStartsWithDot);
         });
         it("name cannot start with underscore", () => {
-            assert.equal(TI.validatePackageName("_foo"), TI.PackageNameValidationResult.NameStartsWithUnderscore);
+            assert.equal(validatePackageName("_foo"), PackageNameValidationResult.NameStartsWithUnderscore);
         });
         it("scoped packages not supported", () => {
-            assert.equal(TI.validatePackageName("@scope/bar"), TI.PackageNameValidationResult.ScopedPackagesNotSupported);
+            assert.equal(validatePackageName("@scope/bar"), PackageNameValidationResult.ScopedPackagesNotSupported);
         });
         it("non URI safe characters are not supported", () => {
-            assert.equal(TI.validatePackageName("  scope  "), TI.PackageNameValidationResult.NameContainsNonURISafeCharacters);
-            assert.equal(TI.validatePackageName("; say ‘Hello from TypeScript!’ #"), TI.PackageNameValidationResult.NameContainsNonURISafeCharacters);
-            assert.equal(TI.validatePackageName("a/b/c"), TI.PackageNameValidationResult.NameContainsNonURISafeCharacters);
+            assert.equal(validatePackageName("  scope  "), PackageNameValidationResult.NameContainsNonURISafeCharacters);
+            assert.equal(validatePackageName("; say ‘Hello from TypeScript!’ #"), PackageNameValidationResult.NameContainsNonURISafeCharacters);
+            assert.equal(validatePackageName("a/b/c"), PackageNameValidationResult.NameContainsNonURISafeCharacters);
         });
     });
 
@@ -1250,7 +1252,7 @@ namespace ts.projectSystem {
             const host = createServerHost([f1, packageFile]);
             let beginEvent: server.BeginInstallTypes;
             let endEvent: server.EndInstallTypes;
-            const installer = new (class extends Installer {
+            const installer: Installer = new (class extends Installer {
                 constructor() {
                     super(host, { globalTypingsCacheLocation: cachePath, typesRegistry: createTypesRegistry("commander") });
                 }

src/harness/virtualFileSystemWithWatch.ts

@@ -28,6 +28,7 @@ namespace ts.TestFSWithWatch {
         executingFilePath?: string;
         currentDirectory?: string;
         newLine?: string;
+        useWindowsStylePaths?: boolean;
     }
 
     export function createWatchedSystem(fileOrFolderList: ReadonlyArray<FileOrFolder>, params?: TestServerHostCreationParameters): TestServerHost {
@@ -39,7 +40,8 @@ namespace ts.TestFSWithWatch {
             params.executingFilePath || getExecutingFilePathFromLibFile(),
             params.currentDirectory || "/",
             fileOrFolderList,
-            params.newLine);
+            params.newLine,
+            params.useWindowsStylePaths);
         return host;
     }
 
@@ -52,7 +54,8 @@ namespace ts.TestFSWithWatch {
             params.executingFilePath || getExecutingFilePathFromLibFile(),
             params.currentDirectory || "/",
             fileOrFolderList,
-            params.newLine);
+            params.newLine,
+            params.useWindowsStylePaths);
         return host;
     }
 
@@ -95,7 +98,7 @@ namespace ts.TestFSWithWatch {
         }
     }
 
-    function getDiffInKeys(map: Map<any>, expectedKeys: ReadonlyArray<string>) {
+    function getDiffInKeys<T>(map: Map<T>, expectedKeys: ReadonlyArray<string>) {
         if (map.size === expectedKeys.length) {
             return "";
         }
@@ -122,8 +125,12 @@ namespace ts.TestFSWithWatch {
         return `\n\nNotInActual: ${notInActual}\nDuplicates: ${duplicates}\nInActualButNotInExpected: ${inActualNotExpected}`;
     }
 
-    function checkMapKeys(caption: string, map: Map<any>, expectedKeys: ReadonlyArray<string>) {
+    export function verifyMapSize(caption: string, map: Map<any>, expectedKeys: ReadonlyArray<string>) {
         assert.equal(map.size, expectedKeys.length, `${caption}: incorrect size of map: Actual keys: ${arrayFrom(map.keys())} Expected: ${expectedKeys}${getDiffInKeys(map, expectedKeys)}`);
+    }
+
+    function checkMapKeys(caption: string, map: Map<any>, expectedKeys: ReadonlyArray<string>) {
+        verifyMapSize(caption, map, expectedKeys);
         for (const name of expectedKeys) {
             assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${arrayFrom(map.keys())}`);
         }
@@ -212,13 +219,13 @@ namespace ts.TestFSWithWatch {
         directoryName: string;
     }
 
-    export class TestServerHost implements server.ServerHost {
+    export class TestServerHost implements server.ServerHost, FormatDiagnosticsHost {
         args: string[] = [];
 
         private readonly output: string[] = [];
 
         private fs: Map<FSEntry> = createMap<FSEntry>();
-        private getCanonicalFileName: (s: string) => string;
+        getCanonicalFileName: (s: string) => string;
         private toPath: (f: string) => Path;
         private timeoutCallbacks = new Callbacks();
         private immediateCallbacks = new Callbacks();
@@ -226,14 +233,21 @@ namespace ts.TestFSWithWatch {
         readonly watchedDirectories = createMultiMap<TestDirectoryWatcher>();
         readonly watchedDirectoriesRecursive = createMultiMap<TestDirectoryWatcher>();
         readonly watchedFiles = createMultiMap<TestFileWatcher>();
+        private readonly executingFilePath: string;
+        private readonly currentDirectory: string;
 
-        constructor(public withSafeList: boolean, public useCaseSensitiveFileNames: boolean, private executingFilePath: string, private currentDirectory: string, fileOrFolderList: ReadonlyArray<FileOrFolder>, public readonly newLine = "\n") {
+        constructor(public withSafeList: boolean, public useCaseSensitiveFileNames: boolean, executingFilePath: string, currentDirectory: string, fileOrFolderList: ReadonlyArray<FileOrFolder>, public readonly newLine = "\n", public readonly useWindowsStylePath?: boolean) {
             this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
             this.toPath = s => toPath(s, currentDirectory, this.getCanonicalFileName);
-
+            this.executingFilePath = this.getHostSpecificPath(executingFilePath);
+            this.currentDirectory = this.getHostSpecificPath(currentDirectory);
             this.reloadFS(fileOrFolderList);
         }
 
+        getNewLine() {
+            return this.newLine;
+        }
+
         toNormalizedAbsolutePath(s: string) {
             return getNormalizedAbsolutePath(s, this.currentDirectory);
         }
@@ -242,11 +256,24 @@ namespace ts.TestFSWithWatch {
             return this.toPath(this.toNormalizedAbsolutePath(s));
         }
 
-        reloadFS(fileOrFolderList: ReadonlyArray<FileOrFolder>) {
+        getHostSpecificPath(s: string) {
+            if (this.useWindowsStylePath && s.startsWith(directorySeparator)) {
+                return "c:/" + s.substring(1);
+            }
+            return s;
+        }
+
+        reloadFS(fileOrFolderList: ReadonlyArray<FileOrFolder>, invokeDirectoryWatcherInsteadOfFileChanged?: boolean) {
             const mapNewLeaves = createMap<true>();
             const isNewFs = this.fs.size === 0;
-            // always inject safelist file in the list of files
-            for (const fileOrDirectory of fileOrFolderList.concat(this.withSafeList ? safeList : [])) {
+            fileOrFolderList = fileOrFolderList.concat(this.withSafeList ? safeList : []);
+            const filesOrFoldersToLoad: ReadonlyArray<FileOrFolder> = !this.useWindowsStylePath ? fileOrFolderList :
+                fileOrFolderList.map<FileOrFolder>(f => {
+                    const result = clone(f);
+                    result.path = this.getHostSpecificPath(f.path);
+                    return result;
+                });
+            for (const fileOrDirectory of filesOrFoldersToLoad) {
                 const path = this.toFullPath(fileOrDirectory.path);
                 mapNewLeaves.set(path, true);
                 // If its a change
@@ -257,7 +284,12 @@ namespace ts.TestFSWithWatch {
                             // Update file
                             if (currentEntry.content !== fileOrDirectory.content) {
                                 currentEntry.content = fileOrDirectory.content;
-                                this.invokeFileWatcher(currentEntry.fullPath, FileWatcherEventKind.Changed);
+                                if (invokeDirectoryWatcherInsteadOfFileChanged) {
+                                    this.invokeDirectoryWatcher(getDirectoryPath(currentEntry.fullPath), currentEntry.fullPath);
+                                }
+                                else {
+                                    this.invokeFileWatcher(currentEntry.fullPath, FileWatcherEventKind.Changed);
+                                }
                             }
                         }
                         else {
@@ -548,7 +580,7 @@ namespace ts.TestFSWithWatch {
             const folder = this.toFolder(directoryName);
 
             // base folder has to be present
-            const base = getDirectoryPath(folder.fullPath);
+            const base = getDirectoryPath(folder.path);
             const baseFolder = this.fs.get(base) as Folder;
             Debug.assert(isFolder(baseFolder));
 
@@ -560,7 +592,7 @@ namespace ts.TestFSWithWatch {
             const file = this.toFile({ path, content });
 
             // base folder has to be present
-            const base = getDirectoryPath(file.fullPath);
+            const base = getDirectoryPath(file.path);
             const folder = this.fs.get(base) as Folder;
             Debug.assert(isFolder(folder));
 

src/lib/dom.generated.d.ts

@@ -4833,6 +4833,7 @@ interface HTMLFormElement extends HTMLElement {
      * Fires when a FORM is about to be submitted.
      */
     submit(): void;
+    reportValidity(): boolean;
     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLFormElement, ev: HTMLElementEventMap[K]) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
     [name: string]: any;
@@ -4961,9 +4962,6 @@ interface HTMLFrameSetElement extends HTMLElement {
     onafterprint: (this: HTMLFrameSetElement, ev: Event) => any;
     onbeforeprint: (this: HTMLFrameSetElement, ev: Event) => any;
     onbeforeunload: (this: HTMLFrameSetElement, ev: BeforeUnloadEvent) => any;
-    /**
-     * Fires when the object receives focus.
-     */
     onhashchange: (this: HTMLFrameSetElement, ev: HashChangeEvent) => any;
     onmessage: (this: HTMLFrameSetElement, ev: MessageEvent) => any;
     onoffline: (this: HTMLFrameSetElement, ev: Event) => any;
@@ -5108,7 +5106,6 @@ interface HTMLIFrameElement extends HTMLElement, GetSVGDocument {
      * Sets or retrieves whether the user can resize the frame.
      */
     noResize: boolean;
-
     readonly sandbox: DOMSettableTokenList;
     /**
      * Sets or retrieves whether the frame can be scrolled.
@@ -8205,6 +8202,7 @@ interface Navigator extends Object, NavigatorID, NavigatorOnLine, NavigatorConte
     readonly pointerEnabled: boolean;
     readonly serviceWorker: ServiceWorkerContainer;
     readonly webdriver: boolean;
+    readonly doNotTrack: string | null;
     readonly hardwareConcurrency: number;
     readonly languages: string[];
     getGamepads(): Gamepad[];
@@ -13257,7 +13255,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     moveBy(x?: number, y?: number): void;
     moveTo(x?: number, y?: number): void;
     msWriteProfilerMark(profilerMarkName: string): void;
-    open(url?: string, target?: string, features?: string, replace?: boolean): Window;
+    open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
     postMessage(message: any, targetOrigin: string, transfer?: any[]): void;
     print(): void;
     prompt(message?: string, _default?: string): string | null;
@@ -14006,7 +14004,7 @@ interface EcKeyAlgorithm extends KeyAlgorithm {
     typedCurve: string;
 }
 
-interface EcKeyImportParams {
+interface EcKeyImportParams extends Algorithm {
     namedCurve: string;
 }
 
@@ -14657,7 +14655,7 @@ declare function matchMedia(mediaQuery: string): MediaQueryList;
 declare function moveBy(x?: number, y?: number): void;
 declare function moveTo(x?: number, y?: number): void;
 declare function msWriteProfilerMark(profilerMarkName: string): void;
-declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window;
+declare function open(url?: string, target?: string, features?: string, replace?: boolean): Window | null;
 declare function postMessage(message: any, targetOrigin: string, transfer?: any[]): void;
 declare function print(): void;
 declare function prompt(message?: string, _default?: string): string | null;

src/lib/es2015.core.d.ts

@@ -10,6 +10,7 @@ interface Array<T> {
      * @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<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
     find(predicate: (value: T, index: number, obj: T[]) => boolean, thisArg?: any): T | undefined;
 
     /**
@@ -350,6 +351,7 @@ interface ReadonlyArray<T> {
      * @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<S extends T>(predicate: (this: void, value: T, index: number, obj: ReadonlyArray<T>) => value is S, thisArg?: any): S | undefined;
     find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): T | undefined;
 
     /**

src/lib/es2017.object.d.ts

@@ -3,7 +3,7 @@ interface ObjectConstructor {
      * Returns an array of values of the enumerable properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
-    values<T>(o: { [s: string]: T }): T[];
+    values<T>(o: { [s: string]: T } | { [n: number]: T }): T[];
 
     /**
      * Returns an array of values of the enumerable properties of an object
@@ -15,7 +15,7 @@ interface ObjectConstructor {
      * Returns an array of key/values of the enumerable properties of an object
      * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
      */
-    entries<T>(o: { [s: string]: T }): [string, T][];
+    entries<T>(o: { [s: string]: T } | { [n: number]: T }): [string, T][];
 
     /**
      * Returns an array of key/values of the enumerable properties of an object

src/lib/es5.d.ts

@@ -1050,7 +1050,8 @@ interface ReadonlyArray<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue?: T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -1062,7 +1063,8 @@ interface ReadonlyArray<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue?: T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: ReadonlyArray<T>) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
@@ -1200,7 +1202,8 @@ interface Array<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduce method calls the callbackfn function one time for each element in the array.
@@ -1212,7 +1215,8 @@ interface Array<T> {
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
       * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
     /**
       * Calls the specified callback function for all the elements in an array, in descending order. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
       * @param callbackfn A function that accepts up to four arguments. The reduceRight method calls the callbackfn function one time for each element in the array.
@@ -1647,7 +1651,8 @@ interface Int8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -1671,7 +1676,8 @@ interface Int8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -1914,7 +1920,8 @@ interface Uint8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -1938,7 +1945,8 @@ interface Uint8Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2181,7 +2189,8 @@ interface Uint8ClampedArray {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2205,7 +2214,8 @@ interface Uint8ClampedArray {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2446,7 +2456,8 @@ interface Int16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2470,7 +2481,8 @@ interface Int16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2714,7 +2726,8 @@ interface Uint16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -2738,7 +2751,8 @@ interface Uint16Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint16Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -2981,7 +2995,8 @@ interface Int32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3005,7 +3020,8 @@ interface Int32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Int32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -3247,7 +3263,8 @@ interface Uint32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3271,7 +3288,8 @@ interface Uint32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -3514,7 +3532,8 @@ interface Float32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3538,7 +3557,8 @@ interface Float32Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float32Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.
@@ -3782,7 +3802,8 @@ interface Float64Array {
       * the accumulation. The first call to the callbackfn function provides this value as an argument
       * instead of an array value.
       */
-    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue?: number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array. The return value of
@@ -3806,7 +3827,8 @@ interface Float64Array {
       * the accumulation. The first call to the callbackfn function provides this value as an
       * argument instead of an array value.
       */
-    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue?: number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number): number;
+    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float64Array) => number, initialValue: number): number;
 
     /**
       * Calls the specified callback function for all the elements in an array, in descending order.

src/lib/webworker.generated.d.ts

@@ -1642,7 +1642,7 @@ interface EcKeyAlgorithm extends KeyAlgorithm {
     typedCurve: string;
 }
 
-interface EcKeyImportParams {
+interface EcKeyImportParams extends Algorithm {
     namedCurve: string;
 }
 

src/server/client.ts

@@ -14,7 +14,7 @@ namespace ts.server {
     }
 
     /* @internal */
-    export function extractMessage(message: string) {
+    export function extractMessage(message: string): string {
         // Read the content length
         const contentLengthPrefix = "Content-Length: ";
         const lines = message.split(/\r?\n/);
@@ -198,7 +198,9 @@ namespace ts.server {
             const request = this.processRequest<protocol.CompletionDetailsRequest>(CommandNames.CompletionDetails, args);
             const response = this.processResponse<protocol.CompletionDetailsResponse>(request);
             Debug.assert(response.body.length === 1, "Unexpected length of completion details response body.");
-            return response.body[0];
+
+            const convertedCodeActions = map(response.body[0].codeActions, codeAction => this.convertCodeActions(codeAction, fileName));
+            return { ...response.body[0], codeActions: convertedCodeActions };
         }
 
         getCompletionEntrySymbol(_fileName: string, _position: number, _entryName: string): Symbol {
@@ -540,6 +542,8 @@ namespace ts.server {
             return response.body.map(entry => this.convertCodeActions(entry, file));
         }
 
+        applyCodeActionCommand = notImplemented;
+
         private createFileLocationOrRangeRequestArgs(positionOrRange: number | TextRange, fileName: string): protocol.FileLocationOrRangeRequestArgs {
             return typeof positionOrRange === "number"
                 ? this.createFileLocationRequestArgs(fileName, positionOrRange)

src/server/editorServices.ts

@@ -220,13 +220,28 @@ namespace ts.server {
 
     interface FilePropertyReader<T> {
         getFileName(f: T): string;
-        getScriptKind(f: T): ScriptKind;
+        getScriptKind(f: T, extraFileExtensions?: JsFileExtensionInfo[]): ScriptKind;
         hasMixedContent(f: T, extraFileExtensions: JsFileExtensionInfo[]): boolean;
     }
 
     const fileNamePropertyReader: FilePropertyReader<string> = {
         getFileName: x => x,
-        getScriptKind: _ => undefined,
+        getScriptKind: (fileName, extraFileExtensions) => {
+            let result: ScriptKind;
+            if (extraFileExtensions) {
+                const fileExtension = getAnyExtensionFromPath(fileName);
+                if (fileExtension) {
+                    some(extraFileExtensions, info => {
+                        if (info.extension === fileExtension) {
+                            result = info.scriptKind;
+                            return true;
+                        }
+                        return false;
+                    });
+                }
+            }
+            return result;
+        },
         hasMixedContent: (fileName, extraFileExtensions) => some(extraFileExtensions, ext => ext.isMixedContent && fileExtensionIs(fileName, ext.extension)),
     };
 
@@ -403,7 +418,7 @@ namespace ts.server {
             this.globalPlugins = opts.globalPlugins || emptyArray;
             this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray;
             this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads;
-            this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(this.host.getExecutingFilePath(), "../typesMap.json") : opts.typesMapLocation;
+            this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(this.getExecutingFilePath(), "../typesMap.json") : opts.typesMapLocation;
 
             Debug.assert(!!this.host.createHash, "'ServerHost.createHash' is required for ProjectService");
 
@@ -431,6 +446,11 @@ namespace ts.server {
                 this.watchFilePath = (host, file, cb, path, watchType, project) => ts.addFilePathWatcherWithLogging(host, file, cb, path, this.createWatcherLog(watchType, project));
                 this.watchDirectory = (host, dir, cb, flags, watchType, project) => ts.addDirectoryWatcherWithLogging(host, dir, cb, flags, this.createWatcherLog(watchType, project));
             }
+            else if (this.logger.loggingEnabled()) {
+                this.watchFile = (host, file, cb, watchType, project) => ts.addFileWatcherWithOnlyTriggerLogging(host, file, cb, this.createWatcherLog(watchType, project));
+                this.watchFilePath = (host, file, cb, path, watchType, project) => ts.addFilePathWatcherWithOnlyTriggerLogging(host, file, cb, path, this.createWatcherLog(watchType, project));
+                this.watchDirectory = (host, dir, cb, flags, watchType, project) => ts.addDirectoryWatcherWithOnlyTriggerLogging(host, dir, cb, flags, this.createWatcherLog(watchType, project));
+            }
             else {
                 this.watchFile = ts.addFileWatcher;
                 this.watchFilePath = ts.addFilePathWatcher;
@@ -447,6 +467,16 @@ namespace ts.server {
             return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);
         }
 
+        /*@internal*/
+        getExecutingFilePath() {
+            return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath());
+        }
+
+        /*@internal*/
+        getNormalizedAbsolutePath(fileName: string) {
+            return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
+        }
+
         /* @internal */
         getChangedFiles_TestOnly() {
             return this.changedFiles;
@@ -539,6 +569,11 @@ namespace ts.server {
             });
         }
 
+        /*@internal*/
+        hasPendingProjectUpdate(project: Project) {
+            return this.pendingProjectUpdates.has(project.getProjectName());
+        }
+
         private sendProjectsUpdatedInBackgroundEvent() {
             if (!this.eventHandler) {
                 return;
@@ -575,9 +610,9 @@ namespace ts.server {
             // always set 'allowNonTsExtensions' for inferred projects since user cannot configure it from the outside
             // previously we did not expose a way for user to change these settings and this option was enabled by default
             compilerOptions.allowNonTsExtensions = true;
-
-            if (projectRootPath) {
-                this.compilerOptionsForInferredProjectsPerProjectRoot.set(projectRootPath, compilerOptions);
+            const canonicalProjectRootPath = projectRootPath && this.toCanonicalFileName(projectRootPath);
+            if (canonicalProjectRootPath) {
+                this.compilerOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, compilerOptions);
             }
             else {
                 this.compilerOptionsForInferredProjects = compilerOptions;
@@ -593,9 +628,9 @@ namespace ts.server {
                 //   root path
                 // - Inferred projects with a projectRootPath, if the new options apply to that
                 //   project root path.
-                if (projectRootPath ?
-                        project.projectRootPath === projectRootPath :
-                        !project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) {
+                if (canonicalProjectRootPath ?
+                    project.projectRootPath === canonicalProjectRootPath :
+                    !project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) {
                     project.setCompilerOptions(compilerOptions);
                     project.compileOnSaveEnabled = compilerOptions.compileOnSave;
                     project.markAsDirty();
@@ -780,8 +815,14 @@ namespace ts.server {
             );
         }
 
+        /** Gets the config file existence info for the configured project */
+        /*@internal*/
+        getConfigFileExistenceInfo(project: ConfiguredProject) {
+            return this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath);
+        }
+
         private onConfigChangedForConfiguredProject(project: ConfiguredProject, eventKind: FileWatcherEventKind) {
-            const configFileExistenceInfo = this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath);
+            const configFileExistenceInfo = this.getConfigFileExistenceInfo(project);
             if (eventKind === FileWatcherEventKind.Deleted) {
                 // Update the cached status
                 // We arent updating or removing the cached config file presence info as that will be taken care of by
@@ -827,6 +868,9 @@ namespace ts.server {
             this.logger.info(`remove project: ${project.getRootFiles().toString()}`);
 
             project.close();
+            if (Debug.shouldAssert(AssertionLevel.Normal)) {
+                this.filenameToScriptInfo.forEach(info => Debug.assert(!info.isAttached(project)));
+            }
             // Remove the project from pending project updates
             this.pendingProjectUpdates.delete(project.getProjectName());
 
@@ -880,18 +924,6 @@ namespace ts.server {
             return project;
         }
 
-        private addToListOfOpenFiles(info: ScriptInfo) {
-            Debug.assert(!info.isOrphan());
-            for (const p of info.containingProjects) {
-                // file is the part of configured project, addref the project
-                if (p.projectKind === ProjectKind.Configured) {
-                    ((<ConfiguredProject>p)).addOpenRef();
-                }
-            }
-
-            this.openFiles.push(info);
-        }
-
         /**
          * Remove this file from the set of open, non-configured files.
          * @param info The file that has been closed or newly configured
@@ -914,10 +946,8 @@ namespace ts.server {
                     if (info.hasMixedContent) {
                         info.registerFileUpdate();
                     }
-                    // Delete the reference to the open configured projects but
-                    // do not remove the project so that we can reuse this project
+                    // Do not remove the project so that we can reuse this project
                     // if it would need to be re-created with next file open
-                    (<ConfiguredProject>p).deleteOpenRef();
                 }
                 else if (p.projectKind === ProjectKind.Inferred && p.isRoot(info)) {
                     // If this was the open root file of inferred project
@@ -1007,7 +1037,7 @@ namespace ts.server {
         }
 
         private setConfigFileExistenceByNewConfiguredProject(project: ConfiguredProject) {
-            const configFileExistenceInfo = this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath);
+            const configFileExistenceInfo = this.getConfigFileExistenceInfo(project);
             if (configFileExistenceInfo) {
                 Debug.assert(configFileExistenceInfo.exists);
                 // close existing watcher
@@ -1036,7 +1066,7 @@ namespace ts.server {
         }
 
         private setConfigFileExistenceInfoByClosedConfiguredProject(closedProject: ConfiguredProject) {
-            const configFileExistenceInfo = this.configFileExistenceInfoCache.get(closedProject.canonicalConfigFilePath);
+            const configFileExistenceInfo = this.getConfigFileExistenceInfo(closedProject);
             Debug.assert(!!configFileExistenceInfo);
             if (configFileExistenceInfo.openFilesImpactedByConfigFile.size) {
                 const configFileName = closedProject.getConfigFilePath();
@@ -1200,7 +1230,7 @@ namespace ts.server {
             projectRootPath?: NormalizedPath) {
             let searchPath = asNormalizedPath(getDirectoryPath(info.fileName));
 
-            while (!projectRootPath || searchPath.indexOf(projectRootPath) >= 0) {
+            while (!projectRootPath || containsPath(projectRootPath, searchPath, this.currentDirectory, !this.host.useCaseSensitiveFileNames)) {
                 const canonicalSearchPath = normalizedPathToPath(searchPath, this.currentDirectory, this.toCanonicalFileName);
                 const tsconfigFileName = asNormalizedPath(combinePaths(searchPath, "tsconfig.json"));
                 let result = action(tsconfigFileName, combinePaths(canonicalSearchPath, "tsconfig.json"));
@@ -1320,10 +1350,10 @@ namespace ts.server {
             const projectOptions: ProjectOptions = {
                 files: parsedCommandLine.fileNames,
                 compilerOptions: parsedCommandLine.options,
-                configHasExtendsProperty: parsedCommandLine.raw["extends"] !== undefined,
-                configHasFilesProperty: parsedCommandLine.raw["files"] !== undefined,
-                configHasIncludeProperty: parsedCommandLine.raw["include"] !== undefined,
-                configHasExcludeProperty: parsedCommandLine.raw["exclude"] !== undefined,
+                configHasExtendsProperty: parsedCommandLine.raw.extends !== undefined,
+                configHasFilesProperty: parsedCommandLine.raw.files !== undefined,
+                configHasIncludeProperty: parsedCommandLine.raw.include !== undefined,
+                configHasExcludeProperty: parsedCommandLine.raw.exclude !== undefined,
                 wildcardDirectories: createMapFromTemplate(parsedCommandLine.wildcardDirectories),
                 typeAcquisition: parsedCommandLine.typeAcquisition,
                 compileOnSave: parsedCommandLine.compileOnSave
@@ -1486,7 +1516,7 @@ namespace ts.server {
                     scriptInfo = normalizedPath;
                 }
                 else {
-                    const scriptKind = propertyReader.getScriptKind(f);
+                    const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions);
                     const hasMixedContent = propertyReader.hasMixedContent(f, this.hostConfiguration.extraFileExtensions);
                     scriptInfo = this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(normalizedPath, scriptKind, hasMixedContent, project.directoryStructureHost);
                     path = scriptInfo.path;
@@ -1561,14 +1591,17 @@ namespace ts.server {
                 project.watchWildcards(projectOptions.wildcardDirectories);
             }
             this.updateNonInferredProject(project, projectOptions.files, fileNamePropertyReader, projectOptions.compilerOptions, projectOptions.typeAcquisition, projectOptions.compileOnSave);
+            this.sendConfigFileDiagEvent(project, configFileName);
+        }
 
+        private sendConfigFileDiagEvent(project: ConfiguredProject, triggerFile: NormalizedPath) {
             if (!this.eventHandler) {
                 return;
             }
 
             this.eventHandler(<ConfigFileDiagEvent>{
                 eventName: ConfigFileDiagEvent,
-                data: { configFileName, diagnostics: project.getGlobalProjectErrors() || [], triggerFile: configFileName }
+                data: { configFileName: project.getConfigFilePath(), diagnostics: project.getAllProjectErrors(), triggerFile }
             });
         }
 
@@ -1578,9 +1611,10 @@ namespace ts.server {
             }
 
             if (projectRootPath) {
+                const canonicalProjectRootPath = this.toCanonicalFileName(projectRootPath);
                 // if we have an explicit project root path, find (or create) the matching inferred project.
                 for (const project of this.inferredProjects) {
-                    if (project.projectRootPath === projectRootPath) {
+                    if (project.projectRootPath === canonicalProjectRootPath) {
                         return project;
                     }
                 }
@@ -1621,12 +1655,13 @@ namespace ts.server {
                 return this.inferredProjects[0];
             }
 
-            return this.createInferredProject(/*rootDirectoryForResolution*/ undefined, /*isSingleInferredProject*/ true);
+            // Single inferred project does not have a project root and hence no current directory
+            return this.createInferredProject(/*currentDirectory*/ undefined, /*isSingleInferredProject*/ true);
         }
 
-        private createInferredProject(rootDirectoryForResolution: string | undefined, isSingleInferredProject?: boolean, projectRootPath?: string): InferredProject {
+        private createInferredProject(currentDirectory: string | undefined, isSingleInferredProject?: boolean, projectRootPath?: string): InferredProject {
             const compilerOptions = projectRootPath && this.compilerOptionsForInferredProjectsPerProjectRoot.get(projectRootPath) || this.compilerOptionsForInferredProjects;
-            const project = new InferredProject(this, this.documentRegistry, compilerOptions, projectRootPath, rootDirectoryForResolution);
+            const project = new InferredProject(this, this.documentRegistry, compilerOptions, projectRootPath, currentDirectory);
             if (isSingleInferredProject) {
                 this.inferredProjects.unshift(project);
             }
@@ -1888,6 +1923,7 @@ namespace ts.server {
 
         openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult {
             let configFileName: NormalizedPath;
+            let sendConfigFileDiagEvent = false;
             let configFileErrors: ReadonlyArray<Diagnostic>;
 
             const info = this.getOrCreateScriptInfoOpenedByClientForNormalizedPath(fileName, fileContent, scriptKind, hasMixedContent);
@@ -1898,14 +1934,8 @@ namespace ts.server {
                     project = this.findConfiguredProjectByProjectName(configFileName);
                     if (!project) {
                         project = this.createConfiguredProject(configFileName);
-
-                        // even if opening config file was successful, it could still
-                        // contain errors that were tolerated.
-                        const errors = project.getGlobalProjectErrors();
-                        if (errors && errors.length > 0) {
-                            // set configFileErrors only when the errors array is non-empty
-                            configFileErrors = errors;
-                        }
+                        // Send the event only if the project got created as part of this open request
+                        sendConfigFileDiagEvent = true;
                     }
                 }
             }
@@ -1919,9 +1949,19 @@ namespace ts.server {
             // At this point if file is part of any any configured or external project, then it would be present in the containing projects
             // So if it still doesnt have any containing projects, it needs to be part of inferred project
             if (info.isOrphan()) {
+                // Since the file isnt part of configured project, do not send config file event
+                configFileName = undefined;
+                sendConfigFileDiagEvent = false;
+
                 this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
             }
-            this.addToListOfOpenFiles(info);
+            Debug.assert(!info.isOrphan());
+            this.openFiles.push(info);
+
+            if (sendConfigFileDiagEvent) {
+                configFileErrors = project.getAllProjectErrors();
+                this.sendConfigFileDiagEvent(project as ConfiguredProject, fileName);
+            }
 
             // Remove the configured projects that have zero references from open files.
             // This was postponed from closeOpenFile to after opening next file,
@@ -1938,6 +1978,7 @@ namespace ts.server {
             // the file from that old project is reopened because of opening file from here.
             this.deleteOrphanScriptInfoNotInAnyProject();
             this.printProjects();
+
             return { configFileName, configFileErrors };
         }
 
@@ -2015,11 +2056,14 @@ namespace ts.server {
             }
         }
 
-        private closeConfiguredProject(configFile: NormalizedPath): boolean {
+        private closeConfiguredProjectReferencedFromExternalProject(configFile: NormalizedPath): boolean {
             const configuredProject = this.findConfiguredProjectByProjectName(configFile);
-            if (configuredProject && configuredProject.deleteOpenRef() === 0) {
-                this.removeProject(configuredProject);
-                return true;
+            if (configuredProject) {
+                configuredProject.deleteExternalProjectReference();
+                if (!configuredProject.hasOpenRef()) {
+                    this.removeProject(configuredProject);
+                    return true;
+                }
             }
             return false;
         }
@@ -2030,7 +2074,7 @@ namespace ts.server {
             if (configFiles) {
                 let shouldRefreshInferredProjects = false;
                 for (const configFile of configFiles) {
-                    if (this.closeConfiguredProject(configFile)) {
+                    if (this.closeConfiguredProjectReferencedFromExternalProject(configFile)) {
                         shouldRefreshInferredProjects = true;
                     }
                 }
@@ -2225,7 +2269,7 @@ namespace ts.server {
                         const newConfig = tsConfigFiles[iNew];
                         const oldConfig = oldConfigFiles[iOld];
                         if (oldConfig < newConfig) {
-                            this.closeConfiguredProject(oldConfig);
+                            this.closeConfiguredProjectReferencedFromExternalProject(oldConfig);
                             iOld++;
                         }
                         else if (oldConfig > newConfig) {
@@ -2240,7 +2284,7 @@ namespace ts.server {
                     }
                     for (let i = iOld; i < oldConfigFiles.length; i++) {
                         // projects for all remaining old config files should be closed
-                        this.closeConfiguredProject(oldConfigFiles[i]);
+                        this.closeConfiguredProjectReferencedFromExternalProject(oldConfigFiles[i]);
                     }
                 }
             }
@@ -2255,7 +2299,7 @@ namespace ts.server {
                     }
                     if (project && !contains(exisingConfigFiles, tsconfigFile)) {
                         // keep project alive even if no documents are opened - its lifetime is bound to the lifetime of containing external project
-                        project.addOpenRef();
+                        project.addExternalProjectReference();
                     }
                 }
             }

src/server/project.ts

@@ -195,6 +195,9 @@ namespace ts.server {
             return result.module;
         }
 
+        /*@internal*/
+        readonly currentDirectory: string;
+
         /*@internal*/
         constructor(
             /*@internal*/readonly projectName: string,
@@ -206,7 +209,8 @@ namespace ts.server {
             private compilerOptions: CompilerOptions,
             public compileOnSaveEnabled: boolean,
             /*@internal*/public directoryStructureHost: DirectoryStructureHost,
-            rootDirectoryForResolution: string | undefined) {
+            currentDirectory: string | undefined) {
+            this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory || "");
 
             this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds);
             if (!this.compilerOptions) {
@@ -229,18 +233,35 @@ namespace ts.server {
                 this.realpath = path => host.realpath(path);
             }
 
+            // Use the current directory as resolution root only if the project created using current directory string
+            this.resolutionCache = createResolutionCache(this, currentDirectory && this.currentDirectory);
             this.languageService = createLanguageService(this, this.documentRegistry);
-            this.resolutionCache = createResolutionCache(this, rootDirectoryForResolution);
             if (!languageServiceEnabled) {
                 this.disableLanguageService();
             }
             this.markAsDirty();
         }
 
+        isKnownTypesPackageName(name: string): boolean {
+            return this.typingsCache.isKnownTypesPackageName(name);
+        }
+        installPackage(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult> {
+            return this.typingsCache.installPackage({ ...options, projectRootPath: this.toPath(this.currentDirectory) });
+        }
+        private get typingsCache(): TypingsCache {
+            return this.projectService.typingsCache;
+        }
+
+        // Method of LanguageServiceHost
         getCompilationSettings() {
             return this.compilerOptions;
         }
 
+        // Method to support public API
+        getCompilerOptions() {
+            return this.getCompilationSettings();
+        }
+
         getNewLine() {
             return this.directoryStructureHost.newLine;
         }
@@ -301,11 +322,11 @@ namespace ts.server {
         }
 
         getCurrentDirectory(): string {
-            return this.directoryStructureHost.getCurrentDirectory();
+            return this.currentDirectory;
         }
 
         getDefaultLibFileName() {
-            const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.host.getExecutingFilePath()));
+            const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.getExecutingFilePath()));
             return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilerOptions));
         }
 
@@ -422,35 +443,36 @@ namespace ts.server {
             if (!this.builder) {
                 this.builder = createBuilder({
                     getCanonicalFileName: this.projectService.toCanonicalFileName,
-                    getEmitOutput: (_program, sourceFile, emitOnlyDts, isDetailed) =>
-                        this.getFileEmitOutput(sourceFile, emitOnlyDts, isDetailed),
-                    computeHash: data =>
-                        this.projectService.host.createHash(data),
-                    shouldEmitFile: sourceFile =>
-                        !this.projectService.getScriptInfoForPath(sourceFile.path).isDynamicOrHasMixedContent()
+                    computeHash: data => this.projectService.host.createHash(data)
                 });
             }
         }
 
+        private shouldEmitFile(scriptInfo: ScriptInfo) {
+            return scriptInfo && !scriptInfo.isDynamicOrHasMixedContent();
+        }
+
         getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[] {
             if (!this.languageServiceEnabled) {
                 return [];
             }
             this.updateGraph();
             this.ensureBuilder();
-            return this.builder.getFilesAffectedBy(this.program, scriptInfo.path);
+            return mapDefined(this.builder.getFilesAffectedBy(this.program, scriptInfo.path),
+                sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : undefined);
         }
 
         /**
          * Returns true if emit was conducted
          */
         emitFile(scriptInfo: ScriptInfo, writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => void): boolean {
-            this.ensureBuilder();
-            const { emitSkipped, outputFiles } = this.builder.emitFile(this.program, scriptInfo.path);
+            if (!this.languageServiceEnabled || !this.shouldEmitFile(scriptInfo)) {
+                return false;
+            }
+            const { emitSkipped, outputFiles } = this.getLanguageService(/*ensureSynchronized*/ false).getEmitOutput(scriptInfo.fileName);
             if (!emitSkipped) {
-                const projectRootPath = this.getProjectRootPath();
                 for (const outputFile of outputFiles) {
-                    const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, projectRootPath ? projectRootPath : getDirectoryPath(scriptInfo.fileName));
+                    const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, this.currentDirectory);
                     writeFile(outputFileAbsoluteFileName, outputFile.text, outputFile.writeByteOrderMark);
                 }
             }
@@ -479,7 +501,6 @@ namespace ts.server {
         getProjectName() {
             return this.projectName;
         }
-        abstract getProjectRootPath(): string | undefined;
         abstract getTypeAcquisition(): TypeAcquisition;
 
         getExternalFiles(): SortedReadonlyArray<string> {
@@ -495,25 +516,23 @@ namespace ts.server {
 
         close() {
             if (this.program) {
-                // if we have a program - release all files that are enlisted in program
+                // if we have a program - release all files that are enlisted in program but arent root
+                // The releasing of the roots happens later
+                // The project could have pending update remaining and hence the info could be in the files but not in program graph
                 for (const f of this.program.getSourceFiles()) {
-                    const info = this.projectService.getScriptInfo(f.fileName);
-                    // We might not find the script info in case its not associated with the project any more
-                    // and project graph was not updated (eg delayed update graph in case of files changed/deleted on the disk)
-                    if (info) {
-                        info.detachFromProject(this);
-                    }
+                    this.detachScriptInfoIfNotRoot(f.fileName);
                 }
             }
-            if (!this.program || !this.languageServiceEnabled) {
-                // release all root files either if there is no program or language service is disabled.
-                // in the latter case set of root files can be larger than the set of files in program.
-                for (const root of this.rootFiles) {
-                    root.detachFromProject(this);
-                }
+            // Release external files
+            forEach(this.externalFiles, externalFile => this.detachScriptInfoIfNotRoot(externalFile));
+            // Always remove root files from the project
+            for (const root of this.rootFiles) {
+                root.detachFromProject(this);
             }
+
             this.rootFiles = undefined;
             this.rootFilesMap = undefined;
+            this.externalFiles = undefined;
             this.program = undefined;
             this.builder = undefined;
             this.resolutionCache.clear();
@@ -532,6 +551,15 @@ namespace ts.server {
             this.languageService = undefined;
         }
 
+        private detachScriptInfoIfNotRoot(uncheckedFilename: string) {
+            const info = this.projectService.getScriptInfo(uncheckedFilename);
+            // We might not find the script info in case its not associated with the project any more
+            // and project graph was not updated (eg delayed update graph in case of files changed/deleted on the disk)
+            if (info && !this.isRoot(info)) {
+                info.detachFromProject(this);
+            }
+        }
+
         isClosed() {
             return this.rootFiles === undefined;
         }
@@ -561,19 +589,12 @@ namespace ts.server {
             return map(this.program.getSourceFiles(), sourceFile => {
                 const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.path);
                 if (!scriptInfo) {
-                    Debug.fail(`scriptInfo for a file '${sourceFile.fileName}' is missing.`);
+                    Debug.fail(`scriptInfo for a file '${sourceFile.fileName}' Path: '${sourceFile.path}' is missing.`);
                 }
                 return scriptInfo;
             });
         }
 
-        private getFileEmitOutput(sourceFile: SourceFile, emitOnlyDtsFiles: boolean, isDetailed: boolean) {
-            if (!this.languageServiceEnabled) {
-                return undefined;
-            }
-            return this.getLanguageService(/*ensureSynchronized*/ false).getEmitOutput(sourceFile.fileName, emitOnlyDtsFiles, isDetailed);
-        }
-
         getExcludedFiles(): ReadonlyArray<NormalizedPath> {
             return emptyArray;
         }
@@ -732,7 +753,6 @@ namespace ts.server {
          */
         updateGraph(): boolean {
             this.resolutionCache.startRecordingFilesWithChangedResolutions();
-            this.hasInvalidatedResolution = this.resolutionCache.createHasInvalidatedResolution();
 
             let hasChanges = this.updateGraphWorker();
 
@@ -792,9 +812,10 @@ namespace ts.server {
 
         private updateGraphWorker() {
             const oldProgram = this.program;
-
+            Debug.assert(!this.isClosed(), "Called update graph worker of closed project");
             this.writeLog(`Starting updateGraphWorker: Project: ${this.getProjectName()}`);
             const start = timestamp();
+            this.hasInvalidatedResolution = this.resolutionCache.createHasInvalidatedResolution();
             this.resolutionCache.startCachingPerDirectoryResolution();
             this.program = this.languageService.getProgram();
             this.resolutionCache.finishCachingPerDirectoryResolution();
@@ -882,9 +903,7 @@ namespace ts.server {
         }
 
         getScriptInfoForNormalizedPath(fileName: NormalizedPath) {
-            const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(
-                fileName, /*scriptKind*/ undefined, /*hasMixedContent*/ undefined, this.directoryStructureHost
-            );
+            const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(fileName);
             if (scriptInfo && !scriptInfo.isAttached(this)) {
                 return Errors.ThrowProjectDoesNotContainDocument(fileName, this);
             }
@@ -892,7 +911,7 @@ namespace ts.server {
         }
 
         getScriptInfo(uncheckedFileName: string) {
-            return this.getScriptInfoForNormalizedPath(toNormalizedPath(uncheckedFileName));
+            return this.projectService.getScriptInfo(uncheckedFileName);
         }
 
         filesToString(writeProjectFileNames: boolean) {
@@ -1037,13 +1056,16 @@ namespace ts.server {
             super.setCompilerOptions(newOptions);
         }
 
+        /** this is canonical project root path */
+        readonly projectRootPath: string | undefined;
+
         /*@internal*/
         constructor(
             projectService: ProjectService,
             documentRegistry: DocumentRegistry,
             compilerOptions: CompilerOptions,
-            public readonly projectRootPath: string | undefined,
-            rootDirectoryForResolution: string | undefined) {
+            projectRootPath: string | undefined,
+            currentDirectory: string | undefined) {
             super(InferredProject.newName(),
                 ProjectKind.Inferred,
                 projectService,
@@ -1053,7 +1075,8 @@ namespace ts.server {
                 compilerOptions,
                 /*compileOnSaveEnabled*/ false,
                 projectService.host,
-                rootDirectoryForResolution);
+                currentDirectory);
+            this.projectRootPath = projectRootPath && projectService.toCanonicalFileName(projectRootPath);
         }
 
         addRoot(info: ScriptInfo) {
@@ -1082,12 +1105,6 @@ namespace ts.server {
                 this.getRootScriptInfos().length === 1;
         }
 
-        getProjectRootPath() {
-            return this.projectRootPath ||
-                // Single inferred project does not have a project root.
-                !this.projectService.useSingleInferredProject && getDirectoryPath(this.getRootFiles()[0]);
-        }
-
         close() {
             forEach(this.getRootScriptInfos(), info => this.projectService.stopWatchingConfigFilesForInferredProjectRoot(info));
             super.close();
@@ -1122,8 +1139,8 @@ namespace ts.server {
 
         private plugins: PluginModule[] = [];
 
-        /** Used for configured projects which may have multiple open roots */
-        openRefCount = 0;
+        /** Ref count to the project when opened from external project */
+        private externalProjectRefCount = 0;
 
         private projectErrors: Diagnostic[];
 
@@ -1183,7 +1200,7 @@ namespace ts.server {
 
             // Search our peer node_modules, then any globally-specified probe paths
             // ../../.. to walk from X/node_modules/typescript/lib/tsserver.js to X/node_modules/
-            const searchPaths = [combinePaths(host.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations];
+            const searchPaths = [combinePaths(this.projectService.getExecutingFilePath(), "../../.."), ...this.projectService.pluginProbeLocations];
 
             if (this.projectService.allowLocalPluginLoads) {
                 const local = getDirectoryPath(this.canonicalConfigFilePath);
@@ -1263,22 +1280,18 @@ namespace ts.server {
             }
         }
 
-        getProjectRootPath() {
-            return getDirectoryPath(this.getConfigFilePath());
-        }
-
         /**
          * Get the errors that dont have any file name associated
          */
         getGlobalProjectErrors(): ReadonlyArray<Diagnostic> {
-            return filter(this.projectErrors, diagnostic => !diagnostic.file);
+            return filter(this.projectErrors, diagnostic => !diagnostic.file) || emptyArray;
         }
 
         /**
          * Get all the project errors
          */
         getAllProjectErrors(): ReadonlyArray<Diagnostic> {
-            return this.projectErrors;
+            return this.projectErrors || emptyArray;
         }
 
         setProjectErrors(projectErrors: Diagnostic[]) {
@@ -1327,27 +1340,54 @@ namespace ts.server {
         }
 
         close() {
-            super.close();
-
             if (this.configFileWatcher) {
                 this.configFileWatcher.close();
                 this.configFileWatcher = undefined;
             }
 
             this.stopWatchingWildCards();
+            this.projectErrors = undefined;
+            this.configFileSpecs = undefined;
+            super.close();
         }
 
-        addOpenRef() {
-            this.openRefCount++;
+        /* @internal */
+        addExternalProjectReference() {
+            this.externalProjectRefCount++;
         }
 
-        deleteOpenRef() {
-            this.openRefCount--;
-            return this.openRefCount;
+        /* @internal */
+        deleteExternalProjectReference() {
+            this.externalProjectRefCount--;
         }
 
+        /** Returns true if the project is needed by any of the open script info/external project */
+        /* @internal */
         hasOpenRef() {
-            return !!this.openRefCount;
+            if (!!this.externalProjectRefCount) {
+                return true;
+            }
+
+            // Closed project doesnt have any reference
+            if (this.isClosed()) {
+                return false;
+            }
+
+            const configFileExistenceInfo = this.projectService.getConfigFileExistenceInfo(this);
+            if (this.projectService.hasPendingProjectUpdate(this)) {
+                // If there is pending update for this project,
+                // we dont know if this project would be needed by any of the open files impacted by this config file
+                // In that case keep the project alive if there are open files impacted by this project
+                return !!configFileExistenceInfo.openFilesImpactedByConfigFile.size;
+            }
+
+            // If there is no pending update for this project,
+            // We know exact set of open files that get impacted by this configured project as the files in the project
+            // The project is referenced only if open files impacted by this project are present in this project
+            return forEachEntry(
+                configFileExistenceInfo.openFilesImpactedByConfigFile,
+                (_value, infoPath) => this.containsScriptInfo(this.projectService.getScriptInfoForPath(infoPath as Path))
+            ) || false;
         }
 
         getEffectiveTypeRoots() {
@@ -1379,13 +1419,14 @@ namespace ts.server {
             compilerOptions: CompilerOptions,
             languageServiceEnabled: boolean,
             public compileOnSaveEnabled: boolean,
-            private readonly projectFilePath?: string) {
+            projectFilePath?: string) {
             super(externalProjectName,
                 ProjectKind.External,
                 projectService,
                 documentRegistry,
                 /*hasExplicitListOfFiles*/ true,
-                languageServiceEnabled, compilerOptions,
+                languageServiceEnabled,
+                compilerOptions,
                 compileOnSaveEnabled,
                 projectService.host,
                 getDirectoryPath(projectFilePath || normalizeSlashes(externalProjectName)));
@@ -1395,16 +1436,6 @@ namespace ts.server {
             return this.excludedFiles;
         }
 
-        getProjectRootPath() {
-            if (this.projectFilePath) {
-                return getDirectoryPath(this.projectFilePath);
-            }
-            // if the projectFilePath is not given, we make the assumption that the project name
-            // is the path of the project file. AS the project name is provided by VS, we need to
-            // normalize slashes before using it as a file name.
-            return getDirectoryPath(normalizeSlashes(this.getProjectName()));
-        }
-
         getTypeAcquisition() {
             return this.typeAcquisition;
         }

src/server/protocol.ts

@@ -94,6 +94,7 @@ namespace ts.server.protocol {
         BreakpointStatement = "breakpointStatement",
         CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects",
         GetCodeFixes = "getCodeFixes",
+        ApplyCodeActionCommand = "applyCodeActionCommand",
         /* @internal */
         GetCodeFixesFull = "getCodeFixes-full",
         GetSupportedCodeFixes = "getSupportedCodeFixes",
@@ -125,6 +126,8 @@ namespace ts.server.protocol {
      * Client-initiated request message
      */
     export interface Request extends Message {
+        type: "request";
+
         /**
          * The command to execute
          */
@@ -147,6 +150,8 @@ namespace ts.server.protocol {
      * Server-initiated event message
      */
     export interface Event extends Message {
+        type: "event";
+
         /**
          * Name of event
          */
@@ -162,6 +167,8 @@ namespace ts.server.protocol {
      * Response by server to client request message.
      */
     export interface Response extends Message {
+        type: "response";
+
         /**
          * Sequence number of the request message.
          */
@@ -178,7 +185,8 @@ namespace ts.server.protocol {
         command: string;
 
         /**
-         * Contains error message if success === false.
+         * If success === false, this should always be provided.
+         * Otherwise, may (or may not) contain a success message.
          */
         message?: string;
 
@@ -520,6 +528,14 @@ namespace ts.server.protocol {
         arguments: CodeFixRequestArgs;
     }
 
+    export interface ApplyCodeActionCommandRequest extends Request {
+        command: CommandTypes.ApplyCodeActionCommand;
+        arguments: ApplyCodeActionCommandRequestArgs;
+    }
+
+    // All we need is the `success` and `message` fields of Response.
+    export interface ApplyCodeActionCommandResponse extends Response {}
+
     export interface FileRangeRequestArgs extends FileRequestArgs {
         /**
          * The line number for the request (1-based).
@@ -564,6 +580,10 @@ namespace ts.server.protocol {
         errorCodes?: number[];
     }
 
+    export interface ApplyCodeActionCommandRequestArgs extends FileRequestArgs {
+        command: {};
+    }
+
     /**
      * Response for GetCodeFixes request.
      */
@@ -1541,6 +1561,8 @@ namespace ts.server.protocol {
         description: string;
         /** Text changes to apply to each file as part of the code action */
         changes: FileCodeEdits[];
+        /** A command is an opaque object that should be passed to `ApplyCodeActionCommandRequestArgs` without modification.  */
+        commands?: {}[];
     }
 
     /**
@@ -1658,6 +1680,11 @@ namespace ts.server.protocol {
          * this span should be used instead of the default one.
          */
         replacementSpan?: TextSpan;
+        /**
+         * Indicates whether commiting this completion entry will require additional code actions to be
+         * made to avoid errors. The CompletionEntryDetails will have these actions.
+         */
+        hasAction?: true;
     }
 
     /**
@@ -1690,6 +1717,11 @@ namespace ts.server.protocol {
          * JSDoc tags for the symbol.
          */
         tags: JSDocTagInfo[];
+
+        /**
+         * The associated code actions for this entry
+         */
+        codeActions?: CodeAction[];
     }
 
     export interface CompletionsResponse extends Response {

src/server/server.ts

@@ -250,6 +250,9 @@ namespace ts.server {
         private activeRequestCount = 0;
         private requestQueue: QueuedOperation[] = [];
         private requestMap = createMap<QueuedOperation>(); // Maps operation ID to newest requestQueue entry with that ID
+        /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
+        private requestedRegistry: boolean;
+        private typesRegistryCache: Map<void> | undefined;
 
         // This number is essentially arbitrary.  Processing more than one typings request
         // at a time makes sense, but having too many in the pipe results in a hang
@@ -258,7 +261,7 @@ namespace ts.server {
         // buffer, but we have yet to find a way to retrieve that value.
         private static readonly maxActiveRequestCount = 10;
         private static readonly requestDelayMillis = 100;
-
+        private packageInstalledPromise: { resolve(value: ApplyCodeActionCommandResult): void, reject(reason: any): void };
 
         constructor(
             private readonly telemetryEnabled: boolean,
@@ -278,6 +281,31 @@ namespace ts.server {
             }
         }
 
+        isKnownTypesPackageName(name: string): boolean {
+            // We want to avoid looking this up in the registry as that is expensive. So first check that it's actually an NPM package.
+            const validationResult = JsTyping.validatePackageName(name);
+            if (validationResult !== JsTyping.PackageNameValidationResult.Ok) {
+                return false;
+            }
+
+            if (this.requestedRegistry) {
+                return !!this.typesRegistryCache && this.typesRegistryCache.has(name);
+            }
+
+            this.requestedRegistry = true;
+            this.send({ kind: "typesRegistry" });
+            return false;
+        }
+
+        installPackage(options: InstallPackageOptionsWithProjectRootPath): Promise<ApplyCodeActionCommandResult> {
+            const rq: InstallPackageRequest = { kind: "installPackage", ...options };
+            this.send(rq);
+            Debug.assert(this.packageInstalledPromise === undefined);
+            return new Promise((resolve, reject) => {
+                this.packageInstalledPromise = { resolve, reject };
+            });
+        }
+
         private reportInstallerProcessId() {
             if (this.installerPidReported) {
                 return;
@@ -343,23 +371,27 @@ namespace ts.server {
         }
 
         onProjectClosed(p: Project): void {
-            this.installer.send({ projectName: p.getProjectName(), kind: "closeProject" });
+            this.send({ projectName: p.getProjectName(), kind: "closeProject" });
+        }
+
+        private send(rq: TypingInstallerRequestUnion): void {
+            this.installer.send(rq);
         }
 
         enqueueInstallTypingsRequest(project: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string>): void {
             const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
             if (this.logger.hasLevel(LogLevel.verbose)) {
                 if (this.logger.hasLevel(LogLevel.verbose)) {
-                    this.logger.info(`Scheduling throttled operation: ${JSON.stringify(request)}`);
+                    this.logger.info(`Scheduling throttled operation:${stringifyIndented(request)}`);
                 }
             }
 
             const operationId = project.getProjectName();
             const operation = () => {
                 if (this.logger.hasLevel(LogLevel.verbose)) {
-                    this.logger.info(`Sending request: ${JSON.stringify(request)}`);
+                    this.logger.info(`Sending request:${stringifyIndented(request)}`);
                 }
-                this.installer.send(request);
+                this.send(request);
             };
             const queuedRequest: QueuedOperation = { operationId, operation };
 
@@ -375,12 +407,26 @@ namespace ts.server {
             }
         }
 
-        private handleMessage(response: SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes | InitializationFailedResponse) {
+        private handleMessage(response: TypesRegistryResponse | PackageInstalledResponse | SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes | InitializationFailedResponse) {
             if (this.logger.hasLevel(LogLevel.verbose)) {
-                this.logger.info(`Received response: ${JSON.stringify(response)}`);
+                this.logger.info(`Received response:${stringifyIndented(response)}`);
             }
 
             switch (response.kind) {
+                case EventTypesRegistry:
+                    this.typesRegistryCache = ts.createMapFromTemplate(response.typesRegistry);
+                    break;
+                case EventPackageInstalled: {
+                    const { success, message } = response;
+                    if (success) {
+                        this.packageInstalledPromise.resolve({ successMessage: message });
+                    }
+                    else {
+                        this.packageInstalledPromise.reject(message);
+                    }
+                    this.packageInstalledPromise = undefined;
+                    break;
+                }
                 case EventInitializationFailed:
                 {
                     if (!this.eventSender) {
@@ -580,7 +626,7 @@ namespace ts.server {
     function createLogger() {
         const cmdLineLogFileName = findArgument("--logFile");
         const cmdLineVerbosity = getLogLevel(findArgument("--logVerbosity"));
-        const envLogOptions = parseLoggingEnvironmentString(process.env["TSS_LOG"]);
+        const envLogOptions = parseLoggingEnvironmentString(process.env.TSS_LOG);
 
         const logFileName = cmdLineLogFileName
             ? stripQuotes(cmdLineLogFileName)
@@ -753,10 +799,23 @@ namespace ts.server {
     const sys = <ServerHost>ts.sys;
     // use watchGuard process on Windows when node version is 4 or later
     const useWatchGuard = process.platform === "win32" && getNodeMajorVersion() >= 4;
+    const originalWatchDirectory: ServerHost["watchDirectory"] = sys.watchDirectory.bind(sys);
+    const noopWatcher: FileWatcher = { close: noop };
+    // This is the function that catches the exceptions when watching directory, and yet lets project service continue to function
+    // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point
+    function watchDirectorySwallowingException(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher {
+        try {
+            return originalWatchDirectory(path, callback, recursive);
+        }
+        catch (e) {
+            logger.info(`Exception when creating directory watcher: ${e.message}`);
+            return noopWatcher;
+        }
+    }
+
     if (useWatchGuard) {
         const currentDrive = extractWatchDirectoryCacheKey(sys.resolvePath(sys.getCurrentDirectory()), /*currentDriveKey*/ undefined);
         const statusCache = createMap<boolean>();
-        const originalWatchDirectory = sys.watchDirectory;
         sys.watchDirectory = function (path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher {
             const cacheKey = extractWatchDirectoryCacheKey(path, currentDrive);
             let status = cacheKey && statusCache.get(cacheKey);
@@ -767,7 +826,7 @@ namespace ts.server {
                 try {
                     const args = [combinePaths(__dirname, "watchGuard.js"), path];
                     if (logger.hasLevel(LogLevel.verbose)) {
-                        logger.info(`Starting ${process.execPath} with args ${JSON.stringify(args)}`);
+                        logger.info(`Starting ${process.execPath} with args:${stringifyIndented(args)}`);
                     }
                     childProcess.execFileSync(process.execPath, args, { stdio: "ignore", env: { "ELECTRON_RUN_AS_NODE": "1" } });
                     status = true;
@@ -790,14 +849,17 @@ namespace ts.server {
             }
             if (status) {
                 // this drive is safe to use - call real 'watchDirectory'
-                return originalWatchDirectory.call(sys, path, callback, recursive);
+                return watchDirectorySwallowingException(path, callback, recursive);
             }
             else {
                 // this drive is unsafe - return no-op watcher
-                return { close() { } };
+                return noopWatcher;
             }
         };
     }
+    else {
+        sys.watchDirectory = watchDirectorySwallowingException;
+    }
 
     // Override sys.write because fs.writeSync is not reliable on Node 4
     sys.write = (s: string) => writeMessage(new Buffer(s, "utf8"));

src/server/session.ts

@@ -131,7 +131,7 @@ namespace ts.server {
 
         const json = JSON.stringify(msg);
         if (verboseLogging) {
-            logger.info(msg.type + ": " + json);
+            logger.info(`${msg.type}:${indent(json)}`);
         }
 
         const len = byteLength(json, "utf8");
@@ -383,9 +383,9 @@ namespace ts.server {
         public logError(err: Error, cmd: string) {
             let msg = "Exception on executing command " + cmd;
             if (err.message) {
-                msg += ":\n" + err.message;
+                msg += ":\n" + indent(err.message);
                 if ((<StackTraceError>err).stack) {
-                    msg += "\n" + (<StackTraceError>err).stack;
+                    msg += "\n" + indent((<StackTraceError>err).stack);
                 }
             }
             this.logger.msg(msg, Msg.Err);
@@ -411,19 +411,27 @@ namespace ts.server {
             this.send(ev);
         }
 
-        public output(info: any, cmdName: string, reqSeq = 0, errorMsg?: string) {
+        // For backwards-compatibility only.
+        public output(info: any, cmdName: string, reqSeq?: number, errorMsg?: string): void {
+            this.doOutput(info, cmdName, reqSeq, /*success*/ !errorMsg, errorMsg);
+        }
+
+        private doOutput(info: {} | undefined, cmdName: string, reqSeq: number, success: boolean, message?: string): void {
             const res: protocol.Response = {
                 seq: 0,
                 type: "response",
                 command: cmdName,
                 request_seq: reqSeq,
-                success: !errorMsg,
+                success,
             };
-            if (!errorMsg) {
+            if (success) {
                 res.body = info;
             }
             else {
-                res.message = errorMsg;
+                Debug.assert(info === undefined);
+            }
+            if (message) {
+                res.message = message;
             }
             this.send(res);
         }
@@ -969,13 +977,7 @@ namespace ts.server {
          * @param fileContent is a version of the file content that is known to be more up to date than the one on disk
          */
         private openClientFile(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, projectRootPath?: NormalizedPath) {
-            const { configFileName, configFileErrors } = this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, /*hasMixedContent*/ false, projectRootPath);
-            if (this.eventHandler) {
-                this.eventHandler({
-                    eventName: "configFileDiag",
-                    data: { triggerFile: fileName, configFileName, diagnostics: configFileErrors || emptyArray }
-                });
-            }
+            this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, /*hasMixedContent*/ false, projectRootPath);
         }
 
         private getPosition(args: protocol.FileLocationRequestArgs, scriptInfo: ScriptInfo): number {
@@ -1184,11 +1186,12 @@ namespace ts.server {
 
             const completions = project.getLanguageService().getCompletionsAtPosition(file, position);
             if (simplifiedResult) {
-                return mapDefined(completions && completions.entries, entry => {
+                return mapDefined<CompletionEntry, protocol.CompletionEntry>(completions && completions.entries, entry => {
                     if (completions.isMemberCompletion || (entry.name.toLowerCase().indexOf(prefix.toLowerCase()) === 0)) {
-                        const { name, kind, kindModifiers, sortText, replacementSpan } = entry;
+                        const { name, kind, kindModifiers, sortText, replacementSpan, hasAction } = entry;
                         const convertedSpan = replacementSpan ? this.decorateSpan(replacementSpan, scriptInfo) : undefined;
-                        return { name, kind, kindModifiers, sortText, replacementSpan: convertedSpan };
+                        // Use `hasAction || undefined` to avoid serializing `false`.
+                        return { name, kind, kindModifiers, sortText, replacementSpan: convertedSpan, hasAction: hasAction || undefined };
                     }
                 }).sort((a, b) => compareStrings(a.name, b.name));
             }
@@ -1199,10 +1202,20 @@ namespace ts.server {
 
         private getCompletionEntryDetails(args: protocol.CompletionDetailsRequestArgs): ReadonlyArray<protocol.CompletionEntryDetails> {
             const { file, project } = this.getFileAndProject(args);
-            const position = this.getPositionInFile(args, file);
+            const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
+            const position = this.getPosition(args, scriptInfo);
+            const formattingOptions = project.projectService.getFormatCodeOptions(file);
 
-            return mapDefined(args.entryNames, entryName =>
-                project.getLanguageService().getCompletionEntryDetails(file, position, entryName));
+            return mapDefined(args.entryNames, entryName => {
+                const details = project.getLanguageService().getCompletionEntryDetails(file, position, entryName, formattingOptions);
+                if (details) {
+                    const mappedCodeActions = map(details.codeActions, action => this.mapCodeAction(action, scriptInfo));
+                    return { ...details, codeActions: mappedCodeActions };
+                }
+                else {
+                    return undefined;
+                }
+            });
         }
 
         private getCompileOnSaveAffectedFileList(args: protocol.FileRequestArgs): ReadonlyArray<protocol.CompileOnSaveAffectedFileListSingleProject> {
@@ -1302,7 +1315,7 @@ namespace ts.server {
             this.changeSeq++;
             // make sure no changes happen before this one is finished
             if (project.reloadScript(file, tempFileName)) {
-                this.output(undefined, CommandNames.Reload, reqSeq);
+                this.doOutput(/*info*/ undefined, CommandNames.Reload, reqSeq, /*success*/ true);
             }
         }
 
@@ -1501,16 +1514,18 @@ namespace ts.server {
             }
 
             if (simplifiedResult) {
-                const file = result.renameFilename;
-                let location: protocol.Location | undefined;
-                if (file !== undefined && result.renameLocation !== undefined) {
-                    const renameScriptInfo = project.getScriptInfoForNormalizedPath(toNormalizedPath(file));
-                    location = renameScriptInfo.positionToLineOffset(result.renameLocation);
+                const { renameFilename, renameLocation, edits } = result;
+                let mappedRenameLocation: protocol.Location | undefined;
+                if (renameFilename !== undefined && renameLocation !== undefined) {
+                    const renameScriptInfo = project.getScriptInfoForNormalizedPath(toNormalizedPath(renameFilename));
+                    const snapshot = renameScriptInfo.getSnapshot();
+                    const oldText = snapshot.getText(0, snapshot.getLength());
+                    mappedRenameLocation = getLocationInNewDocument(oldText, renameFilename, renameLocation, edits);
                 }
                 return {
-                    renameLocation: location,
-                    renameFilename: file,
-                    edits: result.edits.map(change => this.mapTextChangesToCodeEdits(project, change))
+                    renameLocation: mappedRenameLocation,
+                    renameFilename,
+                    edits: edits.map(change => this.mapTextChangesToCodeEdits(project, change))
                 };
             }
             else {
@@ -1540,6 +1555,15 @@ namespace ts.server {
             }
         }
 
+        private applyCodeActionCommand(commandName: string, requestSeq: number, args: protocol.ApplyCodeActionCommandRequestArgs): void {
+            const { file, project } = this.getFileAndProject(args);
+            const output = (success: boolean, message: string) => this.doOutput({}, commandName, requestSeq, success, message);
+            const command = args.command as CodeActionCommand; // They should be sending back the command we sent them.
+            project.getLanguageService().applyCodeActionCommand(file, command).then(
+                ({ successMessage }) => { output(/*success*/ true, successMessage); },
+                error => { output(/*success*/ false, error); });
+        }
+
         private getStartAndEndPosition(args: protocol.FileRangeRequestArgs, scriptInfo: ScriptInfo) {
             let startPosition: number = undefined, endPosition: number = undefined;
             if (args.startPosition !== undefined) {
@@ -1562,14 +1586,12 @@ namespace ts.server {
             return { startPosition, endPosition };
         }
 
-        private mapCodeAction(codeAction: CodeAction, scriptInfo: ScriptInfo): protocol.CodeAction {
-            return {
-                description: codeAction.description,
-                changes: codeAction.changes.map(change => ({
-                    fileName: change.fileName,
-                    textChanges: change.textChanges.map(textChange => this.convertTextChangeToCodeEdit(textChange, scriptInfo))
-                }))
-            };
+        private mapCodeAction({ description, changes: unmappedChanges, commands }: CodeAction, scriptInfo: ScriptInfo): protocol.CodeAction {
+            const changes = unmappedChanges.map(change => ({
+                fileName: change.fileName,
+                textChanges: change.textChanges.map(textChange => this.convertTextChangeToCodeEdit(textChange, scriptInfo))
+            }));
+            return { description,  changes, commands };
         }
 
         private mapTextChangesToCodeEdits(project: Project, textChanges: FileTextChanges): protocol.FileCodeEdits {
@@ -1608,7 +1630,7 @@ namespace ts.server {
             }
 
             // No need to analyze lib.d.ts
-            const fileNamesInProject = fileNames.filter(value => value.indexOf("lib.d.ts") < 0);
+            const fileNamesInProject = fileNames.filter(value => !stringContains(value, "lib.d.ts"));
             if (fileNamesInProject.length === 0) {
                 return;
             }
@@ -1655,15 +1677,15 @@ namespace ts.server {
         exit() {
         }
 
-        private notRequired() {
+        private notRequired(): HandlerResponse {
             return { responseRequired: false };
         }
 
-        private requiredResponse(response: any) {
+        private requiredResponse(response: {}): HandlerResponse {
             return { response, responseRequired: true };
         }
 
-        private handlers = createMapFromTemplate<(request: protocol.Request) => { response?: any, responseRequired?: boolean }>({
+        private handlers = createMapFromTemplate<(request: protocol.Request) => HandlerResponse>({
             [CommandNames.OpenExternalProject]: (request: protocol.OpenExternalProjectRequest) => {
                 this.projectService.openExternalProject(request.arguments, /*suppressRefreshOfInferredProjects*/ false);
                 // TODO: report errors
@@ -1841,7 +1863,7 @@ namespace ts.server {
             },
             [CommandNames.Configure]: (request: protocol.ConfigureRequest) => {
                 this.projectService.setHostConfiguration(request.arguments);
-                this.output(undefined, CommandNames.Configure, request.seq);
+                this.doOutput(/*info*/ undefined, CommandNames.Configure, request.seq, /*success*/ true);
                 return this.notRequired();
             },
             [CommandNames.Reload]: (request: protocol.ReloadRequest) => {
@@ -1908,6 +1930,10 @@ namespace ts.server {
             [CommandNames.GetCodeFixesFull]: (request: protocol.CodeFixRequest) => {
                 return this.requiredResponse(this.getCodeFixes(request.arguments, /*simplifiedResult*/ false));
             },
+            [CommandNames.ApplyCodeActionCommand]: (request: protocol.ApplyCodeActionCommandRequest) => {
+                this.applyCodeActionCommand(request.command, request.seq, request.arguments);
+                return this.notRequired(); // Response will come asynchronously.
+            },
             [CommandNames.GetSupportedCodeFixes]: () => {
                 return this.requiredResponse(this.getSupportedCodeFixes());
             },
@@ -1922,7 +1948,7 @@ namespace ts.server {
             }
         });
 
-        public addProtocolHandler(command: string, handler: (request: protocol.Request) => { response?: any, responseRequired: boolean }) {
+        public addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse) {
             if (this.handlers.has(command)) {
                 throw new Error(`Protocol handler already exists for command "${command}"`);
             }
@@ -1951,14 +1977,14 @@ namespace ts.server {
             }
         }
 
-        public executeCommand(request: protocol.Request): { response?: any, responseRequired?: boolean } {
+        public executeCommand(request: protocol.Request): HandlerResponse {
             const handler = this.handlers.get(request.command);
             if (handler) {
                 return this.executeWithRequestId(request.seq, () => handler(request));
             }
             else {
-                this.logger.msg(`Unrecognized JSON command: ${JSON.stringify(request)}`, Msg.Err);
-                this.output(undefined, CommandNames.Unknown, request.seq, `Unrecognized JSON command: ${request.command}`);
+                this.logger.msg(`Unrecognized JSON command:${stringifyIndented(request)}`, Msg.Err);
+                this.doOutput(/*info*/ undefined, CommandNames.Unknown, request.seq, /*success*/ false, `Unrecognized JSON command: ${request.command}`);
                 return { responseRequired: false };
             }
         }
@@ -1969,7 +1995,7 @@ namespace ts.server {
             if (this.logger.hasLevel(LogLevel.requestTime)) {
                 start = this.hrtime();
                 if (this.logger.hasLevel(LogLevel.verbose)) {
-                    this.logger.info(`request: ${message}`);
+                    this.logger.info(`request:${indent(message)}`);
                 }
             }
 
@@ -1989,25 +2015,53 @@ namespace ts.server {
                 }
 
                 if (response) {
-                    this.output(response, request.command, request.seq);
+                    this.doOutput(response, request.command, request.seq, /*success*/ true);
                 }
                 else if (responseRequired) {
-                    this.output(undefined, request.command, request.seq, "No content available.");
+                    this.doOutput(/*info*/ undefined, request.command, request.seq, /*success*/ false, "No content available.");
                 }
             }
             catch (err) {
                 if (err instanceof OperationCanceledException) {
                     // Handle cancellation exceptions
-                    this.output({ canceled: true }, request.command, request.seq);
+                    this.doOutput({ canceled: true }, request.command, request.seq, /*success*/ true);
                     return;
                 }
                 this.logError(err, message);
-                this.output(
-                    undefined,
+                this.doOutput(
+                    /*info*/ undefined,
                     request ? request.command : CommandNames.Unknown,
                     request ? request.seq : 0,
+                    /*success*/ false,
                     "Error processing request. " + (<StackTraceError>err).message + "\n" + (<StackTraceError>err).stack);
             }
         }
     }
+
+    export interface HandlerResponse {
+        response?: {};
+        responseRequired?: boolean;
+    }
+
+    /* @internal */ // Exported only for tests
+    export function getLocationInNewDocument(oldText: string, renameFilename: string, renameLocation: number, edits: ReadonlyArray<FileTextChanges>): protocol.Location {
+        const newText = applyEdits(oldText, renameFilename, edits);
+        const { line, character } = computeLineAndCharacterOfPosition(computeLineStarts(newText), renameLocation);
+        return { line: line + 1, offset: character + 1 };
+    }
+
+    function applyEdits(text: string, textFilename: string, edits: ReadonlyArray<FileTextChanges>): string {
+        for (const { fileName, textChanges } of edits) {
+            if (fileName !== textFilename) {
+                continue;
+            }
+
+            for (let i = textChanges.length - 1; i >= 0; i--) {
+                const { newText, span: { start, length } } = textChanges[i];
+                text = text.slice(0, start) + newText + text.slice(start + length);
+            }
+        }
+
+        return text;
+    }
 }

src/server/shared.ts

@@ -3,6 +3,8 @@
 namespace ts.server {
     export const ActionSet: ActionSet = "action::set";
     export const ActionInvalidate: ActionInvalidate = "action::invalidate";
+    export const EventTypesRegistry: EventTypesRegistry = "event::typesRegistry";
+    export const EventPackageInstalled: EventPackageInstalled = "event::packageInstalled";
     export const EventBeginInstallTypes: EventBeginInstallTypes = "event::beginInstallTypes";
     export const EventEndInstallTypes: EventEndInstallTypes = "event::endInstallTypes";
     export const EventInitializationFailed: EventInitializationFailed = "event::initializationFailed";

src/server/types.ts

@@ -28,12 +28,14 @@ declare namespace ts.server {
         " __sortedArrayBrand": any;
     }
 
-    export interface TypingInstallerRequest {
+    export interface TypingInstallerRequestWithProjectName {
         readonly projectName: string;
-        readonly kind: "discover" | "closeProject";
     }
 
-    export interface DiscoverTypings extends TypingInstallerRequest {
+    /* @internal */
+    export type TypingInstallerRequestUnion = DiscoverTypings | CloseProject | TypesRegistryRequest | InstallPackageRequest;
+
+    export interface DiscoverTypings extends TypingInstallerRequestWithProjectName {
         readonly fileNames: string[];
         readonly projectRootPath: Path;
         readonly compilerOptions: CompilerOptions;
@@ -43,18 +45,46 @@ declare namespace ts.server {
         readonly kind: "discover";
     }
 
-    export interface CloseProject extends TypingInstallerRequest {
+    export interface CloseProject extends TypingInstallerRequestWithProjectName {
         readonly kind: "closeProject";
     }
 
+    export interface TypesRegistryRequest {
+        readonly kind: "typesRegistry";
+    }
+
+    export interface InstallPackageRequest {
+        readonly kind: "installPackage";
+        readonly fileName: Path;
+        readonly packageName: string;
+        readonly projectRootPath: Path;
+    }
+
     export type ActionSet = "action::set";
     export type ActionInvalidate = "action::invalidate";
+    export type EventTypesRegistry = "event::typesRegistry";
+    export type EventPackageInstalled = "event::packageInstalled";
     export type EventBeginInstallTypes = "event::beginInstallTypes";
     export type EventEndInstallTypes = "event::endInstallTypes";
     export type EventInitializationFailed = "event::initializationFailed";
 
     export interface TypingInstallerResponse {
-        readonly kind: ActionSet | ActionInvalidate | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed;
+        readonly kind: ActionSet | ActionInvalidate | EventTypesRegistry | EventPackageInstalled | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed;
+    }
+    /* @internal */
+    export type TypingInstallerResponseUnion = SetTypings | InvalidateCachedTypings | TypesRegistryResponse | PackageInstalledResponse | InstallTypes | InitializationFailedResponse;
+
+    /* @internal */
+    export interface TypesRegistryResponse extends TypingInstallerResponse {
+        readonly kind: EventTypesRegistry;
+        readonly typesRegistry: MapLike<void>;
+    }
+
+    /* @internal */
+    export interface PackageInstalledResponse extends TypingInstallerResponse {
+        readonly kind: EventPackageInstalled;
+        readonly success: boolean;
+        readonly message: string;
     }
 
     export interface InitializationFailedResponse extends TypingInstallerResponse {

src/server/typingsCache.ts

@@ -1,7 +1,13 @@
 /// <reference path="project.ts"/>
 
 namespace ts.server {
+    export interface InstallPackageOptionsWithProjectRootPath extends InstallPackageOptions {
+        projectRootPath: Path;
+    }
+
     export interface ITypingsInstaller {
+        isKnownTypesPackageName(name: string): boolean;
+        installPackage(options: InstallPackageOptionsWithProjectRootPath): Promise<ApplyCodeActionCommandResult>;
         enqueueInstallTypingsRequest(p: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray<string>): void;
         attach(projectService: ProjectService): void;
         onProjectClosed(p: Project): void;
@@ -9,6 +15,9 @@ namespace ts.server {
     }
 
     export const nullTypingsInstaller: ITypingsInstaller = {
+        isKnownTypesPackageName: returnFalse,
+        // Should never be called because we never provide a types registry.
+        installPackage: notImplemented,
         enqueueInstallTypingsRequest: noop,
         attach: noop,
         onProjectClosed: noop,
@@ -77,6 +86,14 @@ namespace ts.server {
         constructor(private readonly installer: ITypingsInstaller) {
         }
 
+        isKnownTypesPackageName(name: string): boolean {
+            return this.installer.isKnownTypesPackageName(name);
+        }
+
+        installPackage(options: InstallPackageOptionsWithProjectRootPath): Promise<ApplyCodeActionCommandResult> {
+            return this.installer.installPackage(options);
+        }
+
         getTypingsForProject(project: Project, unresolvedImports: SortedReadonlyArray<string>, forceRefresh: boolean): SortedReadonlyArray<string> {
             const typeAcquisition = project.getTypeAcquisition();
 

src/server/typingsInstaller/nodeTypingsInstaller.ts

@@ -53,7 +53,7 @@ namespace ts.server.typingsInstaller {
         }
         try {
             const content = <TypesRegistryFile>JSON.parse(host.readFile(typesRegistryFilePath));
-            return createMapFromTemplate<void>(content.entries);
+            return createMapFromTemplate(content.entries);
         }
         catch (e) {
             if (log.isEnabled()) {
@@ -68,14 +68,18 @@ namespace ts.server.typingsInstaller {
         return combinePaths(normalizeSlashes(globalTypingsCacheLocation), `node_modules/${TypesRegistryPackageName}/index.json`);
     }
 
-    type ExecSync = (command: string, options: { cwd: string, stdio?: "ignore" }) => any;
+    interface ExecSyncOptions {
+        cwd: string;
+        encoding: "utf-8";
+    }
+    type ExecSync = (command: string, options: ExecSyncOptions) => string;
 
     export class NodeTypingsInstaller extends TypingsInstaller {
-        private readonly execSync: ExecSync;
+        private readonly nodeExecSync: ExecSync;
         private readonly npmPath: string;
         readonly typesRegistry: Map<void>;
 
-        private delayedInitializationError: InitializationFailedResponse;
+        private delayedInitializationError: InitializationFailedResponse | undefined;
 
         constructor(globalTypingsCacheLocation: string, typingSafeListLocation: string, typesMapLocation: string, npmLocation: string | undefined, throttleLimit: number, log: Log) {
             super(
@@ -88,14 +92,14 @@ namespace ts.server.typingsInstaller {
             this.npmPath = npmLocation !== undefined ? npmLocation : getDefaultNPMLocation(process.argv[0]);
 
             // If the NPM path contains spaces and isn't wrapped in quotes, do so.
-            if (this.npmPath.indexOf(" ") !== -1 && this.npmPath[0] !== `"`) {
+            if (stringContains(this.npmPath, " ") && this.npmPath[0] !== `"`) {
                 this.npmPath = `"${this.npmPath}"`;
             }
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Process id: ${process.pid}`);
                 this.log.writeLine(`NPM location: ${this.npmPath} (explicit '${Arguments.NpmLocation}' ${npmLocation === undefined ? "not " : ""} provided)`);
             }
-            ({ execSync: this.execSync } = require("child_process"));
+            ({ execSync: this.nodeExecSync } = require("child_process"));
 
             this.ensurePackageDirectoryExists(globalTypingsCacheLocation);
 
@@ -103,7 +107,7 @@ namespace ts.server.typingsInstaller {
                 if (this.log.isEnabled()) {
                     this.log.writeLine(`Updating ${TypesRegistryPackageName} npm package...`);
                 }
-                this.execSync(`${this.npmPath} install --ignore-scripts ${TypesRegistryPackageName}`, { cwd: globalTypingsCacheLocation, stdio: "ignore" });
+                this.execSyncAndLog(`${this.npmPath} install --ignore-scripts ${TypesRegistryPackageName}`, { cwd: globalTypingsCacheLocation });
                 if (this.log.isEnabled()) {
                     this.log.writeLine(`Updated ${TypesRegistryPackageName} npm package`);
                 }
@@ -123,7 +127,7 @@ namespace ts.server.typingsInstaller {
         }
 
         listen() {
-            process.on("message", (req: DiscoverTypings | CloseProject) => {
+            process.on("message", (req: TypingInstallerRequestUnion) => {
                 if (this.delayedInitializationError) {
                     // report initializationFailed error
                     this.sendResponse(this.delayedInitializationError);
@@ -135,13 +139,41 @@ namespace ts.server.typingsInstaller {
                         break;
                     case "closeProject":
                         this.closeProject(req);
+                        break;
+                    case "typesRegistry": {
+                        const typesRegistry: { [key: string]: void } = {};
+                        this.typesRegistry.forEach((value, key) => {
+                            typesRegistry[key] = value;
+                        });
+                        const response: TypesRegistryResponse = { kind: EventTypesRegistry, typesRegistry };
+                        this.sendResponse(response);
+                        break;
+                    }
+                    case "installPackage": {
+                        const { fileName, packageName, projectRootPath } = req;
+                        const cwd = getDirectoryOfPackageJson(fileName, this.installTypingHost) || projectRootPath;
+                        if (cwd) {
+                            this.installWorker(-1, [packageName], cwd, success => {
+                                const message = success ? `Package ${packageName} installed.` : `There was an error installing ${packageName}.`;
+                                const response: PackageInstalledResponse = { kind: EventPackageInstalled, success, message };
+                                this.sendResponse(response);
+                            });
+                        }
+                        else {
+                            const response: PackageInstalledResponse = { kind: EventPackageInstalled, success: false, message: "Could not determine a project root path." };
+                            this.sendResponse(response);
+                        }
+                        break;
+                    }
+                    default:
+                        Debug.assertNever(req);
                 }
             });
         }
 
-        protected sendResponse(response: SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes | InitializationFailedResponse) {
+        protected sendResponse(response: TypingInstallerResponseUnion) {
             if (this.log.isEnabled()) {
-                this.log.writeLine(`Sending response: ${JSON.stringify(response)}`);
+                this.log.writeLine(`Sending response:\n    ${JSON.stringify(response)}`);
             }
             process.send(response);
             if (this.log.isEnabled()) {
@@ -149,28 +181,45 @@ namespace ts.server.typingsInstaller {
             }
         }
 
-        protected installWorker(requestId: number, args: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void {
+        protected installWorker(requestId: number, packageNames: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void {
             if (this.log.isEnabled()) {
-                this.log.writeLine(`#${requestId} with arguments'${JSON.stringify(args)}'.`);
+                this.log.writeLine(`#${requestId} with arguments'${JSON.stringify(packageNames)}'.`);
             }
-            const command = `${this.npmPath} install --ignore-scripts ${args.join(" ")} --save-dev --user-agent="typesInstaller/${version}"`;
+            const command = `${this.npmPath} install --ignore-scripts ${packageNames.join(" ")} --save-dev --user-agent="typesInstaller/${version}"`;
             const start = Date.now();
-            let stdout: Buffer;
-            let stderr: Buffer;
-            let hasError = false;
-            try {
-                stdout = this.execSync(command, { cwd });
-            }
-            catch (e) {
-                stdout = e.stdout;
-                stderr = e.stderr;
-                hasError = true;
-            }
+            const hasError = this.execSyncAndLog(command, { cwd });
             if (this.log.isEnabled()) {
-                this.log.writeLine(`npm install #${requestId} took: ${Date.now() - start} ms${sys.newLine}stdout: ${stdout && stdout.toString()}${sys.newLine}stderr: ${stderr && stderr.toString()}`);
+                this.log.writeLine(`npm install #${requestId} took: ${Date.now() - start} ms`);
             }
             onRequestCompleted(!hasError);
         }
+
+        /** Returns 'true' in case of error. */
+        private execSyncAndLog(command: string, options: Pick<ExecSyncOptions, "cwd">): boolean {
+            if (this.log.isEnabled()) {
+                this.log.writeLine(`Exec: ${command}`);
+            }
+            try {
+                const stdout = this.nodeExecSync(command, { ...options, encoding: "utf-8" });
+                if (this.log.isEnabled()) {
+                    this.log.writeLine(`    Succeeded. stdout:${indent(sys.newLine, stdout)}`);
+                }
+                return false;
+            }
+            catch (error) {
+                const { stdout, stderr } = error;
+                this.log.writeLine(`    Failed. stdout:${indent(sys.newLine, stdout)}${sys.newLine}    stderr:${indent(sys.newLine, stderr)}`);
+                return true;
+            }
+        }
+    }
+
+    function getDirectoryOfPackageJson(fileName: string, host: InstallTypingHost): string | undefined {
+        return forEachAncestorDirectory(getDirectoryPath(fileName), directory => {
+            if (host.fileExists(combinePaths(directory, "package.json"))) {
+                return directory;
+            }
+        });
     }
 
     const logFilePath = findArgument(server.Arguments.LogFile);
@@ -193,4 +242,8 @@ namespace ts.server.typingsInstaller {
     });
     const installer = new NodeTypingsInstaller(globalTypingsCacheLocation, typingSafeListLocation, typesMapLocation, npmLocation, /*throttleLimit*/5, log);
     installer.listen();
+
+    function indent(newline: string, string: string): string {
+        return `${newline}    ` + string.replace(/\r?\n/, `${newline}    `);
+    }
 }

src/server/typingsInstaller/typingsInstaller.ts

@@ -32,50 +32,11 @@ namespace ts.server.typingsInstaller {
         }
     }
 
-    export enum PackageNameValidationResult {
-        Ok,
-        ScopedPackagesNotSupported,
-        EmptyName,
-        NameTooLong,
-        NameStartsWithDot,
-        NameStartsWithUnderscore,
-        NameContainsNonURISafeCharacters
-    }
-
-
-    export const MaxPackageNameLength = 214;
-    /**
-     * Validates package name using rules defined at https://docs.npmjs.com/files/package.json
-     */
-    export function validatePackageName(packageName: string): PackageNameValidationResult {
-        if (!packageName) {
-            return PackageNameValidationResult.EmptyName;
-        }
-        if (packageName.length > MaxPackageNameLength) {
-            return PackageNameValidationResult.NameTooLong;
-        }
-        if (packageName.charCodeAt(0) === CharacterCodes.dot) {
-            return PackageNameValidationResult.NameStartsWithDot;
-        }
-        if (packageName.charCodeAt(0) === CharacterCodes._) {
-            return PackageNameValidationResult.NameStartsWithUnderscore;
-        }
-        // check if name is scope package like: starts with @ and has one '/' in the middle
-        // scoped packages are not currently supported
-        // TODO: when support will be added we'll need to split and check both scope and package name
-        if (/^@[^/]+\/[^/]+$/.test(packageName)) {
-            return PackageNameValidationResult.ScopedPackagesNotSupported;
-        }
-        if (encodeURIComponent(packageName) !== packageName) {
-            return PackageNameValidationResult.NameContainsNonURISafeCharacters;
-        }
-        return PackageNameValidationResult.Ok;
-    }
 
     export type RequestCompletedAction = (success: boolean) => void;
     interface PendingRequest {
         requestId: number;
-        args: string[];
+        packageNames: string[];
         cwd: string;
         onRequestCompleted: RequestCompletedAction;
     }
@@ -255,8 +216,8 @@ namespace ts.server.typingsInstaller {
                 if (this.missingTypingsSet.get(typing) || this.packageNameToTypingLocation.get(typing)) {
                     continue;
                 }
-                const validationResult = validatePackageName(typing);
-                if (validationResult === PackageNameValidationResult.Ok) {
+                const validationResult = JsTyping.validatePackageName(typing);
+                if (validationResult === JsTyping.PackageNameValidationResult.Ok) {
                     if (this.typesRegistry.has(typing)) {
                         result.push(typing);
                     }
@@ -270,26 +231,7 @@ namespace ts.server.typingsInstaller {
                     // add typing name to missing set so we won't process it again
                     this.missingTypingsSet.set(typing, true);
                     if (this.log.isEnabled()) {
-                        switch (validationResult) {
-                            case PackageNameValidationResult.EmptyName:
-                                this.log.writeLine(`Package name '${typing}' cannot be empty`);
-                                break;
-                            case PackageNameValidationResult.NameTooLong:
-                                this.log.writeLine(`Package name '${typing}' should be less than ${MaxPackageNameLength} characters`);
-                                break;
-                            case PackageNameValidationResult.NameStartsWithDot:
-                                this.log.writeLine(`Package name '${typing}' cannot start with '.'`);
-                                break;
-                            case PackageNameValidationResult.NameStartsWithUnderscore:
-                                this.log.writeLine(`Package name '${typing}' cannot start with '_'`);
-                                break;
-                            case PackageNameValidationResult.ScopedPackagesNotSupported:
-                                this.log.writeLine(`Package '${typing}' is scoped and currently is not supported`);
-                                break;
-                            case PackageNameValidationResult.NameContainsNonURISafeCharacters:
-                                this.log.writeLine(`Package name '${typing}' contains non URI safe characters`);
-                                break;
-                        }
+                        this.log.writeLine(JsTyping.renderPackageNameValidationFailure(validationResult, typing));
                     }
                 }
             }
@@ -430,8 +372,8 @@ namespace ts.server.typingsInstaller {
             };
         }
 
-        private installTypingsAsync(requestId: number, args: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void {
-            this.pendingRunRequests.unshift({ requestId, args, cwd, onRequestCompleted });
+        private installTypingsAsync(requestId: number, packageNames: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void {
+            this.pendingRunRequests.unshift({ requestId, packageNames, cwd, onRequestCompleted });
             this.executeWithThrottling();
         }
 
@@ -439,7 +381,7 @@ namespace ts.server.typingsInstaller {
             while (this.inFlightRequestCount < this.throttleLimit && this.pendingRunRequests.length) {
                 this.inFlightRequestCount++;
                 const request = this.pendingRunRequests.pop();
-                this.installWorker(request.requestId, request.args, request.cwd, ok => {
+                this.installWorker(request.requestId, request.packageNames, request.cwd, ok => {
                     this.inFlightRequestCount--;
                     request.onRequestCompleted(ok);
                     this.executeWithThrottling();
@@ -447,7 +389,7 @@ namespace ts.server.typingsInstaller {
             }
         }
 
-        protected abstract installWorker(requestId: number, args: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void;
+        protected abstract installWorker(requestId: number, packageNames: string[], cwd: string, onRequestCompleted: RequestCompletedAction): void;
         protected abstract sendResponse(response: SetTypings | InvalidateCachedTypings | BeginInstallTypes | EndInstallTypes): void;
     }
 

src/server/utilities.ts

@@ -318,4 +318,15 @@ namespace ts.server {
             deleted(oldItems[oldIndex++]);
         }
     }
+
+    /* @internal */
+    export function indent(string: string): string {
+        return "\n    " + string;
+    }
+
+    /** Put stringified JSON on the next line, indented. */
+    /* @internal */
+    export function stringifyIndented(json: {}): string {
+        return "\n    " + JSON.stringify(json);
+    }
 }

src/services/codeFixProvider.ts

@@ -5,15 +5,13 @@ namespace ts {
         getCodeActions(context: CodeFixContext): CodeAction[] | undefined;
     }
 
-    export interface CodeFixContext {
+    export interface CodeFixContext extends textChanges.TextChangesContext {
         errorCode: number;
         sourceFile: SourceFile;
         span: TextSpan;
         program: Program;
-        newLineCharacter: string;
         host: LanguageServiceHost;
         cancellationToken: CancellationToken;
-        rulesProvider: formatting.RulesProvider;
     }
 
     export namespace codefix {