Merge remote-tracking branch 'upstream/master'

.gitignore

@@ -9,12 +9,14 @@ test-args.txt
 \#*\#
 .\#*
 tests/baselines/local/*
+tests/baselines/local.old/*
 tests/services/baselines/local/*
 tests/baselines/prototyping/local/*
 tests/baselines/rwc/*
 tests/baselines/test262/*
 tests/baselines/reference/projectOutput/*
 tests/baselines/local/projectOutput/*
+tests/baselines/reference/testresults.tap
 tests/services/baselines/prototyping/local/*
 tests/services/browser/typescriptServices.js
 scripts/authors.js
@@ -39,7 +41,9 @@ tests/cases/**/*.js.map
 scripts/debug.bat
 scripts/run.bat
 scripts/word2md.js
+scripts/buildProtocol.js
 scripts/ior.js
+scripts/buildProtocol.js
 scripts/*.js.map
 scripts/typings/
 coverage/
@@ -52,3 +56,4 @@ internal/
 !tests/cases/projects/projectOption/**/node_modules
 !tests/cases/projects/NodeModulesSearch/**/*
 !tests/baselines/reference/project/nodeModules*/**/*
+.idea

.travis.yml

@@ -3,7 +3,6 @@ language: node_js
 node_js:
   - 'stable'
   - '4'
-  - '0.10'
 
 sudo: false
 
@@ -12,18 +11,11 @@ env:
 
 matrix:
   fast_finish: true
-  include:
-  - os: osx
-    node_js: stable
-    osx_image: xcode7.3
-    env: workerCount=2
-  allow_failures:
-  - os: osx
 
 branches:
   only:
   - master
-  - transforms
+  - release-2.0
 
 install:
   - npm uninstall typescript

CONTRIBUTING.md

@@ -40,10 +40,6 @@ In general, things we find useful when reviewing suggestions are:
 
 # Instructions for Contributing Code
 
-## Code of Conduct
-
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
-
 ## Contributing bug fixes
 
 TypeScript is currently accepting contributions in the form of bug fixes. A bug must have an issue tracking it in the issue tracker that has been approved ("Milestone == Community") by the TypeScript team. Your pull request should include a link to the bug that you are fixing. If you've submitted a PR for a bug, please post a comment in the bug to avoid duplication of effort.

Gulpfile.ts

@@ -17,7 +17,6 @@ declare module "gulp-typescript" {
         stripInternal?: boolean;
         types?: string[];
     }
-    interface CompileStream extends NodeJS.ReadWriteStream { } // Either gulp or gulp-typescript has some odd typings which don't reflect reality, making this required
 }
 import * as insert from "gulp-insert";
 import * as sourcemaps from "gulp-sourcemaps";
@@ -39,9 +38,11 @@ const gulp = helpMaker(originalGulp);
 const mochaParallel = require("./scripts/mocha-parallel.js");
 const {runTestsInParallel} = mochaParallel;
 
+Error.stackTraceLimit = 1000;
+
 const cmdLineOptions = minimist(process.argv.slice(2), {
     boolean: ["debug", "light", "colors", "lint", "soft"],
-    string: ["browser", "tests", "host", "reporter"],
+    string: ["browser", "tests", "host", "reporter", "stackTraceLimit"],
     alias: {
         d: "debug",
         t: "tests",
@@ -167,7 +168,7 @@ for (const i in libraryTargets) {
     gulp.task(target, false, [], function() {
         return gulp.src(sources)
             .pipe(newer(target))
-            .pipe(concat(target, { newLine: "" }))
+            .pipe(concat(target, { newLine: "\n\n" }))
             .pipe(gulp.dest("."));
     });
 }
@@ -378,10 +379,10 @@ gulp.task(builtLocalCompiler, false, [servicesFile], () => {
     return localCompilerProject.src()
         .pipe(newer(builtLocalCompiler))
         .pipe(sourcemaps.init())
-        .pipe(tsc(localCompilerProject))
+        .pipe(localCompilerProject())
         .pipe(prependCopyright())
         .pipe(sourcemaps.write("."))
-        .pipe(gulp.dest(builtLocalDirectory));
+        .pipe(gulp.dest("."));
 });
 
 gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => {
@@ -389,7 +390,7 @@ gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => {
     const {js, dts} = servicesProject.src()
         .pipe(newer(servicesFile))
         .pipe(sourcemaps.init())
-        .pipe(tsc(servicesProject));
+        .pipe(servicesProject());
     const completedJs = js.pipe(prependCopyright())
         .pipe(sourcemaps.write("."));
     const completedDts = dts.pipe(prependCopyright(/*outputCopyright*/true))
@@ -407,26 +408,52 @@ gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => {
                 file.path = nodeDefinitionsFile;
                 return content + "\r\nexport = ts;";
             }))
-            .pipe(gulp.dest(builtLocalDirectory)),
+            .pipe(gulp.dest(".")),
         completedDts.pipe(clone())
             .pipe(insert.transform((content, file) => {
                 file.path = nodeStandaloneDefinitionsFile;
                 return content.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
             }))
-    ]).pipe(gulp.dest(builtLocalDirectory));
+    ]).pipe(gulp.dest("."));
+});
+
+// cancellationToken.js
+const cancellationTokenJs = path.join(builtLocalDirectory, "cancellationToken.js");
+gulp.task(cancellationTokenJs, false, [servicesFile], () => {
+    const cancellationTokenProject = tsc.createProject("src/server/cancellationToken/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    return cancellationTokenProject.src()
+        .pipe(newer(cancellationTokenJs))
+        .pipe(sourcemaps.init())
+        .pipe(cancellationTokenProject())
+        .pipe(prependCopyright())
+        .pipe(sourcemaps.write("."))
+        .pipe(gulp.dest(builtLocalDirectory));
+});
+
+// typingsInstallerFile.js
+const typingsInstallerJs = path.join(builtLocalDirectory, "typingsInstaller.js");
+gulp.task(typingsInstallerJs, false, [servicesFile], () => {
+    const cancellationTokenProject = tsc.createProject("src/server/typingsInstaller/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    return cancellationTokenProject.src()
+        .pipe(newer(typingsInstallerJs))
+        .pipe(sourcemaps.init())
+        .pipe(cancellationTokenProject())
+        .pipe(prependCopyright())
+        .pipe(sourcemaps.write("."))
+        .pipe(gulp.dest("."));
 });
 
 const serverFile = path.join(builtLocalDirectory, "tsserver.js");
 
-gulp.task(serverFile, false, [servicesFile], () => {
+gulp.task(serverFile, false, [servicesFile, typingsInstallerJs, cancellationTokenJs], () => {
     const serverProject = tsc.createProject("src/server/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
     return serverProject.src()
         .pipe(newer(serverFile))
         .pipe(sourcemaps.init())
-        .pipe(tsc(serverProject))
+        .pipe(serverProject())
         .pipe(prependCopyright())
         .pipe(sourcemaps.write("."))
-        .pipe(gulp.dest(builtLocalDirectory));
+        .pipe(gulp.dest("."));
 });
 
 const tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js");
@@ -437,14 +464,14 @@ gulp.task(tsserverLibraryFile, false, [servicesFile], (done) => {
     const {js, dts}: { js: NodeJS.ReadableStream, dts: NodeJS.ReadableStream } = serverLibraryProject.src()
         .pipe(sourcemaps.init())
         .pipe(newer(tsserverLibraryFile))
-        .pipe(tsc(serverLibraryProject));
+        .pipe(serverLibraryProject());
 
     return merge2([
         js.pipe(prependCopyright())
             .pipe(sourcemaps.write("."))
-            .pipe(gulp.dest(builtLocalDirectory)),
+            .pipe(gulp.dest(".")),
         dts.pipe(prependCopyright())
-            .pipe(gulp.dest(builtLocalDirectory))
+            .pipe(gulp.dest("."))
     ]);
 });
 
@@ -452,7 +479,6 @@ gulp.task("lssl", "Builds language service server library", [tsserverLibraryFile
 gulp.task("local", "Builds the full compiler and services", [builtLocalCompiler, servicesFile, serverFile, builtGeneratedDiagnosticMessagesJSON, tsserverLibraryFile]);
 gulp.task("tsc", "Builds only the compiler", [builtLocalCompiler]);
 
-
 // Generate Markdown spec
 const word2mdJs = path.join(scriptsDirectory, "word2md.js");
 const word2mdTs = path.join(scriptsDirectory, "word2md.ts");
@@ -491,7 +517,7 @@ gulp.task("useDebugMode", false, [], (done) => { useDebugMode = true; done(); })
 gulp.task("dontUseDebugMode", false, [], (done) => { useDebugMode = false; done(); });
 
 gulp.task("VerifyLKG", false, [], () => {
-    const expectedFiles = [builtLocalCompiler, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile].concat(libraryTargets);
+    const expectedFiles = [builtLocalCompiler, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile, typingsInstallerJs, cancellationTokenJs].concat(libraryTargets);
     const missingFiles = expectedFiles.filter(function(f) {
         return !fs.existsSync(f);
     });
@@ -517,9 +543,9 @@ gulp.task(run, false, [servicesFile], () => {
     return testProject.src()
         .pipe(newer(run))
         .pipe(sourcemaps.init())
-        .pipe(tsc(testProject))
+        .pipe(testProject())
         .pipe(sourcemaps.write(".", { includeContent: false, sourceRoot: "../../" }))
-        .pipe(gulp.dest(builtLocalDirectory));
+        .pipe(gulp.dest("."));
 });
 
 const internalTests = "internal/";
@@ -551,7 +577,7 @@ function restoreSavedNodeEnv() {
     process.env.NODE_ENV = savedNodeEnv;
 }
 
-let testTimeout = 20000;
+let testTimeout = 40000;
 function runConsoleTests(defaultReporter: string, runInParallel: boolean, done: (e?: any) => void) {
     const lintFlag = cmdLineOptions["lint"];
     cleanTestDirs((err) => {
@@ -559,6 +585,7 @@ function runConsoleTests(defaultReporter: string, runInParallel: boolean, done:
         const debug = cmdLineOptions["debug"];
         const tests = cmdLineOptions["tests"];
         const light = cmdLineOptions["light"];
+        const stackTraceLimit = cmdLineOptions["stackTraceLimit"];
         const testConfigFile = "test.config";
         if (fs.existsSync(testConfigFile)) {
             fs.unlinkSync(testConfigFile);
@@ -578,7 +605,7 @@ function runConsoleTests(defaultReporter: string, runInParallel: boolean, done:
         }
 
         if (tests || light || taskConfigsFolder) {
-            writeTestConfigFile(tests, light, taskConfigsFolder, workerCount);
+            writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, stackTraceLimit);
         }
 
         if (tests && tests.toLocaleLowerCase() === "rwc") {
@@ -698,16 +725,16 @@ declare module "convert-source-map" {
 }
 
 gulp.task("browserify", "Runs browserify on run.js to produce a file suitable for running tests in the browser", [servicesFile], (done) => {
-    const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({ outFile: "built/local/bundle.js" }, /*useBuiltCompiler*/ true));
+    const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({ outFile: "../../built/local/bundle.js" }, /*useBuiltCompiler*/ true));
     return testProject.src()
         .pipe(newer("built/local/bundle.js"))
         .pipe(sourcemaps.init())
-        .pipe(tsc(testProject))
+        .pipe(testProject())
         .pipe(through2.obj((file, enc, next) => {
             const originalMap = file.sourceMap;
             const prebundledContent = file.contents.toString();
             // Make paths absolute to help sorcery deal with all the terrible paths being thrown around
-            originalMap.sources = originalMap.sources.map(s => path.resolve("src", s));
+            originalMap.sources = originalMap.sources.map(s => path.resolve(s));
             // intoStream (below) makes browserify think the input file is named this, so this is what it puts in the sourcemap
             originalMap.file = "built/local/_stream_0.js";
 
@@ -727,6 +754,7 @@ gulp.task("browserify", "Runs browserify on run.js to produce a file suitable fo
                         sourcemaps: {
                             "built/local/_stream_0.js": originalMap,
                             "built/local/bundle.js": maps,
+                            "node_modules/source-map-support/source-map-support.js": undefined,
                         }
                     });
                     const finalMap = chain.apply();
@@ -756,8 +784,8 @@ 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) {
-    const testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light: light, workerCount: workerCount, taskConfigsFolder: taskConfigsFolder });
+function writeTestConfigFile(tests: string, light: boolean, taskConfigsFolder?: string, workerCount?: number, stackTraceLimit?: string) {
+    const testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light, workerCount, stackTraceLimit, taskConfigsFolder });
     console.log("Running tests with config: " + testConfigContents);
     fs.writeFileSync("test.config", testConfigContents);
 }
@@ -887,7 +915,7 @@ gulp.task(loggedIOJsPath, false, [], (done) => {
     const temp = path.join(builtLocalDirectory, "temp");
     mkdirP(temp, (err) => {
         if (err) { console.error(err); done(err); process.exit(1); };
-        exec(host, [LKGCompiler, "--outdir", temp, loggedIOpath], () => {
+        exec(host, [LKGCompiler, "--types --outdir", temp, loggedIOpath], () => {
             fs.renameSync(path.join(temp, "/harness/loggedIO.js"), loggedIOJsPath);
             del(temp).then(() => done(), done);
         }, done);
@@ -908,8 +936,8 @@ gulp.task(instrumenterJsPath, false, [servicesFile], () => {
         .pipe(gulp.dest("."));
 });
 
-gulp.task("tsc-instrumented", "Builds an instrumented tsc.js", [loggedIOJsPath, instrumenterJsPath, servicesFile], (done) => {
-    exec(host, [instrumenterJsPath, "record", "iocapture", builtLocalDirectory, compilerFilename], done, done);
+gulp.task("tsc-instrumented", "Builds an instrumented tsc.js", ["local", loggedIOJsPath, instrumenterJsPath, servicesFile], (done) => {
+    exec(host, [instrumenterJsPath, "record", "iocapture", builtLocalCompiler], done, done);
 });
 
 gulp.task("update-sublime", "Updates the sublime plugin's tsserver", ["local", serverFile], () => {

Jakefile.js

@@ -11,6 +11,8 @@ var runTestsInParallel = require("./scripts/mocha-parallel").runTestsInParallel;
 var compilerDirectory = "src/compiler/";
 var servicesDirectory = "src/services/";
 var serverDirectory = "src/server/";
+var typingsInstallerDirectory = "src/server/typingsInstaller";
+var cancellationTokenDirectory = "src/server/cancellationToken";
 var harnessDirectory = "src/harness/";
 var libraryDirectory = "src/lib/";
 var scriptsDirectory = "scripts/";
@@ -64,7 +66,21 @@ var compilerSources = [
     "utilities.ts",
     "binder.ts",
     "checker.ts",
+    "factory.ts",
+    "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es2015.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es2017.ts",
+    "transformers/es2016.ts",
+    "transformers/es2015.ts",
+    "transformers/generators.ts",
+    "transformer.ts",
     "sourcemap.ts",
+    "comments.ts",
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
@@ -85,7 +101,21 @@ var servicesSources = [
     "utilities.ts",
     "binder.ts",
     "checker.ts",
+    "factory.ts",
+    "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es2015.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es2017.ts",
+    "transformers/es2016.ts",
+    "transformers/es2015.ts",
+    "transformers/generators.ts",
+    "transformer.ts",
     "sourcemap.ts",
+    "comments.ts",
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
@@ -94,15 +124,29 @@ var servicesSources = [
 ].map(function (f) {
     return path.join(compilerDirectory, f);
 }).concat([
+    "types.ts",
+    "utilities.ts",
     "breakpoints.ts",
+    "classifier.ts",
+    "completions.ts",
+    "documentHighlights.ts",
+    "documentRegistry.ts",
+    "findAllReferences.ts",
+    "goToDefinition.ts",
+    "goToImplementation.ts",
+    "jsDoc.ts",
+    "jsTyping.ts",
     "navigateTo.ts",
     "navigationBar.ts",
     "outliningElementsCollector.ts",
     "patternMatcher.ts",
+    "preProcess.ts",
+    "rename.ts",
     "services.ts",
     "shims.ts",
     "signatureHelp.ts",
-    "utilities.ts",
+    "symbolDisplay.ts",
+    "transpile.ts",
     "formatting/formatting.ts",
     "formatting/formattingContext.ts",
     "formatting/formattingRequestKind.ts",
@@ -124,20 +168,47 @@ var servicesSources = [
 }));
 
 var serverCoreSources = [
+    "types.d.ts",
+    "utilities.ts",
+    "scriptVersionCache.ts",
+    "typingsCache.ts",
+    "scriptInfo.ts",
+    "lsHost.ts",
+    "project.ts",
     "editorServices.ts",
-    "protocol.d.ts",
+    "protocol.ts",
     "session.ts",
     "server.ts"
 ].map(function (f) {
     return path.join(serverDirectory, f);
 });
 
+var cancellationTokenSources = [
+    "cancellationToken.ts"
+].map(function (f) {
+    return path.join(cancellationTokenDirectory, f);
+});
+
+var typingsInstallerSources = [
+    "../types.d.ts",
+    "typingsInstaller.ts",
+    "nodeTypingsInstaller.ts"
+].map(function (f) {
+    return path.join(typingsInstallerDirectory, f);
+});
+
 var serverSources = serverCoreSources.concat(servicesSources);
 
 var languageServiceLibrarySources = [
+    "protocol.ts",
+    "utilities.ts",
+    "scriptVersionCache.ts",
+    "scriptInfo.ts",
+    "lsHost.ts",
+    "project.ts",
     "editorServices.ts",
-    "protocol.d.ts",
-    "session.ts"
+    "session.ts",
+
 ].map(function (f) {
     return path.join(serverDirectory, f);
 }).concat(servicesSources);
@@ -177,18 +248,27 @@ var harnessSources = harnessCoreSources.concat([
     "moduleResolution.ts",
     "tsconfigParsing.ts",
     "commandLineParsing.ts",
+    "configurationExtension.ts",
     "convertCompilerOptionsFromJson.ts",
     "convertTypingOptionsFromJson.ts",
     "tsserverProjectSystem.ts",
+    "compileOnSave.ts",
+    "typingsInstaller.ts",
+    "projectErrors.ts",
     "matchFiles.ts",
     "initializeTSConfig.ts",
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
-    "protocol.d.ts",
+    "protocol.ts",
+    "utilities.ts",
+    "scriptVersionCache.ts",
+    "scriptInfo.ts",
+    "lsHost.ts",
+    "project.ts",
+    "typingsCache.ts",
+    "editorServices.ts",
     "session.ts",
-    "client.ts",
-    "editorServices.ts"
 ].map(function (f) {
     return path.join(serverDirectory, f);
 }));
@@ -307,7 +387,10 @@ var builtLocalCompiler = path.join(builtLocalDirectory, compilerFilename);
     * @param callback: a function to execute after the compilation process ends
     */
 function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts, callback) {
-    file(outFile, prereqs, function () {
+    file(outFile, prereqs, function() {
+        if (process.env.USE_TRANSFORMS === "false") {
+            useBuiltCompiler = false;
+        }
         var startCompileTime = mark();
         opts = opts || {};
         var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
@@ -435,6 +518,40 @@ compileFile(processDiagnosticMessagesJs,
     [],
             /*useBuiltCompiler*/ false);
 
+var buildProtocolTs = path.join(scriptsDirectory, "buildProtocol.ts");
+var buildProtocolJs = path.join(scriptsDirectory, "buildProtocol.js");
+var buildProtocolDts = path.join(builtLocalDirectory, "protocol.d.ts");
+var typescriptServicesDts = path.join(builtLocalDirectory, "typescriptServices.d.ts");
+
+file(buildProtocolTs);
+
+compileFile(buildProtocolJs,
+    [buildProtocolTs],
+    [buildProtocolTs],
+    [],
+    /*useBuiltCompiler*/ false,
+    {noOutFile: true});
+
+file(buildProtocolDts, [buildProtocolTs, buildProtocolJs, typescriptServicesDts], function() {
+
+    var protocolTs = path.join(serverDirectory, "protocol.ts");
+
+    var cmd = host + " " + buildProtocolJs + " "+ protocolTs + " " + typescriptServicesDts + " " + buildProtocolDts;
+    console.log(cmd);
+    var ex = jake.createExec([cmd]);
+    // Add listeners for output and error
+    ex.addListener("stdout", function (output) {
+        process.stdout.write(output);
+    });
+    ex.addListener("stderr", function (error) {
+        process.stderr.write(error);
+    });
+    ex.addListener("cmdEnd", function () {
+        complete();
+    });
+    ex.run();
+}, { async: true })
+
 // The generated diagnostics map; built for the compiler and for the 'generate-diagnostics' task
 file(diagnosticInfoMapTs, [processDiagnosticMessagesJs, diagnosticMessagesJson], function () {
     var cmd = host + " " + processDiagnosticMessagesJs + " " + diagnosticMessagesJson;
@@ -572,8 +689,16 @@ compileFile(
         inlineSourceMap: true
     });
 
+file(typescriptServicesDts, [servicesFile]);
+
+var cancellationTokenFile = path.join(builtLocalDirectory, "cancellationToken.js");
+compileFile(cancellationTokenFile, cancellationTokenSources, [builtLocalDirectory].concat(cancellationTokenSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { outDir: builtLocalDirectory, noOutFile: true });
+
+var typingsInstallerFile = path.join(builtLocalDirectory, "typingsInstaller.js");
+compileFile(typingsInstallerFile, typingsInstallerSources, [builtLocalDirectory].concat(typingsInstallerSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { outDir: builtLocalDirectory, noOutFile: false });
+
 var serverFile = path.join(builtLocalDirectory, "tsserver.js");
-compileFile(serverFile, serverSources, [builtLocalDirectory, copyright].concat(serverSources), /*prefixes*/[copyright], /*useBuiltCompiler*/ true, { types: ["node"] });
+compileFile(serverFile, serverSources, [builtLocalDirectory, copyright, cancellationTokenFile, typingsInstallerFile].concat(serverSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { types: ["node"] });
 var tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js");
 var tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverlibrary.d.ts");
 compileFile(
@@ -600,7 +725,7 @@ task("build-fold-end", [], function () {
 
 // Local target to build the compiler and services
 desc("Builds the full compiler and services");
-task("local", ["build-fold-start", "generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, builtGeneratedDiagnosticMessagesJSON, "lssl", "build-fold-end"]);
+task("local", ["build-fold-start", "generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile, serverFile, buildProtocolDts, builtGeneratedDiagnosticMessagesJSON, "lssl", "build-fold-end"]);
 
 // Local target to build only tsc.js
 desc("Builds only the compiler");
@@ -656,7 +781,7 @@ task("generate-spec", [specMd]);
 // Makes a new LKG. This target does not build anything, but errors if not all the outputs are present in the built/local directory
 desc("Makes a new LKG out of the built js files");
 task("LKG", ["clean", "release", "local"].concat(libraryTargets), function () {
-    var expectedFiles = [tscFile, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile].concat(libraryTargets);
+    var expectedFiles = [tscFile, servicesFile, serverFile, nodePackageFile, nodeDefinitionsFile, standaloneDefinitionsFile, tsserverLibraryFile, tsserverLibraryDefinitionFile, cancellationTokenFile, typingsInstallerFile, buildProtocolDts].concat(libraryTargets);
     var missingFiles = expectedFiles.filter(function (f) {
         return !fs.existsSync(f);
     });
@@ -745,8 +870,14 @@ function cleanTestDirs() {
 }
 
 // used to pass data from jake command line directly to run.js
-function writeTestConfigFile(tests, light, taskConfigsFolder, workerCount) {
-    var testConfigContents = JSON.stringify({ test: tests ? [tests] : undefined, light: light, workerCount: workerCount, taskConfigsFolder: taskConfigsFolder });
+function writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, stackTraceLimit) {
+    var testConfigContents = JSON.stringify({
+        test: tests ? [tests] : undefined,
+        light: light,
+        workerCount: workerCount,
+        taskConfigsFolder: taskConfigsFolder,
+        stackTraceLimit: stackTraceLimit
+    });
     fs.writeFileSync('test.config', testConfigContents);
 }
 
@@ -757,10 +888,15 @@ function deleteTemporaryProjectOutput() {
 }
 
 function runConsoleTests(defaultReporter, runInParallel) {
-    cleanTestDirs();
+    var dirty = process.env.dirty;
+    if (!dirty) {
+        cleanTestDirs();
+    }
+
     var debug = process.env.debug || process.env.d;
     tests = process.env.test || process.env.tests || process.env.t;
     var light = process.env.light || false;
+    var stackTraceLimit = process.env.stackTraceLimit;
     var testConfigFile = 'test.config';
     if (fs.existsSync(testConfigFile)) {
         fs.unlinkSync(testConfigFile);
@@ -780,7 +916,7 @@ function runConsoleTests(defaultReporter, runInParallel) {
     }
 
     if (tests || light || taskConfigsFolder) {
-        writeTestConfigFile(tests, light, taskConfigsFolder, workerCount);
+        writeTestConfigFile(tests, light, taskConfigsFolder, workerCount, stackTraceLimit);
     }
 
     if (tests && tests.toLocaleLowerCase() === "rwc") {
@@ -849,7 +985,7 @@ function runConsoleTests(defaultReporter, runInParallel) {
         }
     }
     function runLinter() {
-        if (!lintFlag) {
+        if (!lintFlag || dirty) {
             return;
         }
         var lint = jake.Task['lint'];
@@ -866,8 +1002,8 @@ task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], functio
     runConsoleTests('min', /*runInParallel*/ true);
 }, { async: true });
 
-desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true bail=false.");
-task("runtests", ["build-rules", "tests", builtLocalDirectory], function () {
+desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true bail=false dirty=false.");
+task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
     runConsoleTests('mocha-fivemat-progress-reporter', /*runInParallel*/ false);
 }, { async: true });
 
@@ -884,8 +1020,8 @@ var nodeServerInFile = "tests/webTestServer.ts";
 compileFile(nodeServerOutFile, [nodeServerInFile], [builtLocalDirectory, tscFile], [], /*useBuiltCompiler:*/ true, { noOutFile: true });
 
 desc("Runs browserify on run.js to produce a file suitable for running tests in the browser");
-task("browserify", ["tests", builtLocalDirectory, nodeServerOutFile], function () {
-    var cmd = 'browserify built/local/run.js -d -o built/local/bundle.js';
+task("browserify", ["tests", builtLocalDirectory, nodeServerOutFile], function() {
+    var cmd = 'browserify built/local/run.js -t ./scripts/browserify-optional -d -o built/local/bundle.js';
     exec(cmd);
 }, { async: true });
 
@@ -893,7 +1029,7 @@ desc("Runs the tests using the built run.js file like 'jake runtests'. Syntax is
 task("runtests-browser", ["tests", "browserify", builtLocalDirectory, servicesFileInBrowserTest], function () {
     cleanTestDirs();
     host = "node";
-    browser = process.env.browser || process.env.b || "IE";
+    browser = process.env.browser || process.env.b ||  (os.platform() === "linux" ? "chrome" : "IE");
     tests = process.env.test || process.env.tests || process.env.t;
     var light = process.env.light || false;
     var testConfigFile = 'test.config';
@@ -951,15 +1087,18 @@ function acceptBaseline(containerFolder) {
     var deleteEnding = '.delete';
     for (var i in files) {
         var filename = files[i];
-        if (filename.substr(filename.length - deleteEnding.length) === deleteEnding) {
-            filename = filename.substr(0, filename.length - deleteEnding.length);
-            fs.unlinkSync(path.join(targetFolder, filename));
-        } else {
-            var target = path.join(targetFolder, filename);
-            if (fs.existsSync(target)) {
-                fs.unlinkSync(target);
+        var fullLocalPath = path.join(sourceFolder, filename);
+        if (fs.statSync(fullLocalPath).isFile()) {
+            if (filename.substr(filename.length - deleteEnding.length) === deleteEnding) {
+                filename = filename.substr(0, filename.length - deleteEnding.length);
+                fs.unlinkSync(path.join(targetFolder, filename));
+            } else {
+                var target = path.join(targetFolder, filename);
+                if (fs.existsSync(target)) {
+                    fs.unlinkSync(target);
+                }
+                fs.renameSync(path.join(sourceFolder, filename), target);
             }
-            fs.renameSync(path.join(sourceFolder, filename), target);
         }
     }
 }
@@ -998,7 +1137,7 @@ var loggedIOJsPath = builtLocalDirectory + 'loggedIO.js';
 file(loggedIOJsPath, [builtLocalDirectory, loggedIOpath], function () {
     var temp = builtLocalDirectory + 'temp';
     jake.mkdirP(temp);
-    var options = "--outdir " + temp + ' ' + loggedIOpath;
+    var options = "--types --outdir " + temp + ' ' + loggedIOpath;
     var cmd = host + " " + LKGDirectory + compilerFilename + " " + options + " ";
     console.log(cmd + "\n");
     var ex = jake.createExec([cmd]);
@@ -1072,6 +1211,8 @@ var lintTargets = compilerSources
     .concat(serverCoreSources)
     .concat(tslintRulesFiles)
     .concat(servicesSources)
+    .concat(typingsInstallerSources)
+    .concat(cancellationTokenSources)
     .concat(["Gulpfile.ts"])
     .concat([nodeServerInFile, perftscPath, "tests/perfsys.ts", webhostPath]);
 

README.md

@@ -30,8 +30,12 @@ There are many ways to [contribute](https://github.com/Microsoft/TypeScript/blob
 * Engage with other TypeScript users and developers on [StackOverflow](http://stackoverflow.com/questions/tagged/typescript). 
 * Join the [#typescript](http://twitter.com/#!/search/realtime/%23typescript) discussion on Twitter.
 * [Contribute bug fixes](https://github.com/Microsoft/TypeScript/blob/master/CONTRIBUTING.md).
-* Read the language specification ([docx](https://github.com/Microsoft/TypeScript/blob/master/doc/TypeScript%20Language%20Specification.docx?raw=true), [pdf](https://github.com/Microsoft/TypeScript/blob/master/doc/TypeScript%20Language%20Specification.pdf?raw=true), [md](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)).
+* Read the language specification ([docx](https://github.com/Microsoft/TypeScript/blob/master/doc/TypeScript%20Language%20Specification.docx?raw=true),
+ [pdf](https://github.com/Microsoft/TypeScript/blob/master/doc/TypeScript%20Language%20Specification.pdf?raw=true), [md](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)).
 
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see 
+the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) 
+with any additional questions or comments.
 
 ## Documentation
 
@@ -91,4 +95,4 @@ node built/local/tsc.js hello.ts
 
 ## Roadmap
 
-For details on our planned features and future direction please refer to our [roadmap](https://github.com/Microsoft/TypeScript/wiki/Roadmap).
+For details on our planned features and future direction please refer to our [roadmap](https://github.com/Microsoft/TypeScript/wiki/Roadmap).

issue_template.md

@@ -2,7 +2,7 @@
 <!-- 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:**  1.8.0 / nightly (2.0.0-dev.201xxxxx)
+**TypeScript Version:**  2.0.3 / nightly (2.1.0-dev.201xxxxx)
 
 **Code**
 

lib/cancellationToken.js

@@ -0,0 +1,41 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+"use strict";
+var fs = require("fs");
+function createCancellationToken(args) {
+    var cancellationPipeName;
+    for (var i = 0; i < args.length - 1; i++) {
+        if (args[i] === "--cancellationPipeName") {
+            cancellationPipeName = args[i + 1];
+            break;
+        }
+    }
+    if (!cancellationPipeName) {
+        return { isCancellationRequested: function () { return false; } };
+    }
+    return {
+        isCancellationRequested: function () {
+            try {
+                fs.statSync(cancellationPipeName);
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+    };
+}
+module.exports = createCancellationToken;

lib/lib.dom.d.ts

@@ -142,6 +142,7 @@ interface KeyAlgorithm {
 }
 
 interface KeyboardEventInit extends EventModifierInit {
+    code?: string;
     key?: string;
     location?: number;
     repeat?: boolean;
@@ -2304,7 +2305,7 @@ declare var DeviceRotationRate: {
     new(): DeviceRotationRate;
 }
 
-interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
+interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent, ParentNode {
     /**
       * Sets or gets the URL for the current document. 
       */
@@ -3367,7 +3368,7 @@ declare var Document: {
     new(): Document;
 }
 
-interface DocumentFragment extends Node, NodeSelector {
+interface DocumentFragment extends Node, NodeSelector, ParentNode {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -3436,7 +3437,7 @@ declare var EXT_texture_filter_anisotropic: {
     readonly TEXTURE_MAX_ANISOTROPY_EXT: number;
 }
 
-interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode {
+interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode, ParentNode {
     readonly classList: DOMTokenList;
     className: string;
     readonly clientHeight: number;
@@ -3691,6 +3692,16 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     getElementsByClassName(classNames: string): NodeListOf<Element>;
     matches(selector: string): boolean;
     closest(selector: string): Element | null;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element | null;
+    insertAdjacentHTML(where: string, html: string): void;
+    insertAdjacentText(where: string, text: string): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -4462,7 +4473,7 @@ interface HTMLCanvasElement extends HTMLElement {
       * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
       */
     toDataURL(type?: string, ...args: any[]): string;
-    toBlob(callback: (result: Blob | null) => void, ... arguments: any[]): void;
+    toBlob(callback: (result: Blob | null) => void, type?: string, ...arguments: any[]): void;
 }
 
 declare var HTMLCanvasElement: {
@@ -4637,11 +4648,7 @@ interface HTMLElement extends Element {
     click(): void;
     dragDrop(): boolean;
     focus(): void;
-    insertAdjacentElement(position: string, insertedElement: Element): Element;
-    insertAdjacentHTML(where: string, html: string): void;
-    insertAdjacentText(where: string, text: string): void;
     msGetInputContext(): MSInputMethodContext;
-    scrollIntoView(top?: boolean): void;
     setActive(): void;
     addEventListener(type: "MSContentZoom", listener: (this: this, ev: UIEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -5906,6 +5913,7 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle {
       */
     type: string;
     import?: Document;
+    integrity: string;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -6194,7 +6202,7 @@ interface HTMLMediaElement extends HTMLElement {
       */
     canPlayType(type: string): string;
     /**
-      * Fires immediately after the client loads the object.
+      * Resets the audio or video object and loads a new media resource.
       */
     load(): void;
     /**
@@ -6767,6 +6775,7 @@ interface HTMLScriptElement extends HTMLElement {
       * Sets or retrieves the MIME type for the associated scripting engine.
       */
     type: string;
+    integrity: string;
 }
 
 declare var HTMLScriptElement: {
@@ -7543,11 +7552,12 @@ declare var HashChangeEvent: {
 interface History {
     readonly length: number;
     readonly state: any;
-    back(distance?: any): void;
-    forward(distance?: any): void;
-    go(delta?: any): void;
-    pushState(statedata: any, title?: string, url?: string): void;
-    replaceState(statedata: any, title?: string, url?: string): void;
+    scrollRestoration: ScrollRestoration;
+    back(): void;
+    forward(): void;
+    go(delta?: number): void;
+    pushState(data: any, title: string, url?: string | null): void;
+    replaceState(data: any, title: string, url?: string | null): void;
 }
 
 declare var History: {
@@ -7772,6 +7782,7 @@ interface KeyboardEvent extends UIEvent {
     readonly repeat: boolean;
     readonly shiftKey: boolean;
     readonly which: number;
+    readonly code: string;
     getModifierState(keyArg: string): boolean;
     initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     readonly DOM_KEY_LOCATION_JOYSTICK: number;
@@ -9144,6 +9155,7 @@ interface PerformanceTiming {
     readonly responseStart: number;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
+    readonly secureConnectionStart: number;
     toJSON(): any;
 }
 
@@ -11421,8 +11433,8 @@ declare var StereoPannerNode: {
 interface Storage {
     readonly length: number;
     clear(): void;
-    getItem(key: string): string;
-    key(index: number): string;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
     removeItem(key: string): void;
     setItem(key: string, data: string): void;
     [key: string]: any;
@@ -12963,7 +12975,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onunload: (this: this, ev: Event) => any;
     onvolumechange: (this: this, ev: Event) => any;
     onwaiting: (this: this, ev: Event) => any;
-    readonly opener: Window;
+    opener: any;
     orientation: string | number;
     readonly outerHeight: number;
     readonly outerWidth: number;
@@ -13018,6 +13030,9 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    scroll(options?: ScrollToOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollBy(options?: ScrollToOptions): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -13114,7 +13129,6 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     addEventListener(type: "waiting", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
     addEventListener(type: "wheel", listener: (this: this, ev: WheelEvent) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
-    [index: number]: Window;
 }
 
 declare var Window: {
@@ -13145,7 +13159,7 @@ declare var XMLDocument: {
 }
 
 interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
-    onreadystatechange: (this: this, ev: ProgressEvent) => any;
+    onreadystatechange: (this: this, ev: Event) => any;
     readonly readyState: number;
     readonly response: any;
     readonly responseText: string;
@@ -13172,13 +13186,13 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
     readonly LOADING: number;
     readonly OPENED: number;
     readonly UNSENT: number;
-    addEventListener(type: "abort", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
-    addEventListener(type: "error", listener: (this: this, ev: ErrorEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "load", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "loadend", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "loadstart", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "progress", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "readystatechange", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
     addEventListener(type: "timeout", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
@@ -13519,183 +13533,183 @@ interface NavigatorUserMedia {
 }
 
 interface NodeSelector {
-    querySelector(selectors: "a"): HTMLAnchorElement;
-    querySelector(selectors: "abbr"): HTMLElement;
-    querySelector(selectors: "acronym"): HTMLElement;
-    querySelector(selectors: "address"): HTMLElement;
-    querySelector(selectors: "applet"): HTMLAppletElement;
-    querySelector(selectors: "area"): HTMLAreaElement;
-    querySelector(selectors: "article"): HTMLElement;
-    querySelector(selectors: "aside"): HTMLElement;
-    querySelector(selectors: "audio"): HTMLAudioElement;
-    querySelector(selectors: "b"): HTMLElement;
-    querySelector(selectors: "base"): HTMLBaseElement;
-    querySelector(selectors: "basefont"): HTMLBaseFontElement;
-    querySelector(selectors: "bdo"): HTMLElement;
-    querySelector(selectors: "big"): HTMLElement;
-    querySelector(selectors: "blockquote"): HTMLQuoteElement;
-    querySelector(selectors: "body"): HTMLBodyElement;
-    querySelector(selectors: "br"): HTMLBRElement;
-    querySelector(selectors: "button"): HTMLButtonElement;
-    querySelector(selectors: "canvas"): HTMLCanvasElement;
-    querySelector(selectors: "caption"): HTMLTableCaptionElement;
-    querySelector(selectors: "center"): HTMLElement;
-    querySelector(selectors: "circle"): SVGCircleElement;
-    querySelector(selectors: "cite"): HTMLElement;
-    querySelector(selectors: "clippath"): SVGClipPathElement;
-    querySelector(selectors: "code"): HTMLElement;
-    querySelector(selectors: "col"): HTMLTableColElement;
-    querySelector(selectors: "colgroup"): HTMLTableColElement;
-    querySelector(selectors: "datalist"): HTMLDataListElement;
-    querySelector(selectors: "dd"): HTMLElement;
-    querySelector(selectors: "defs"): SVGDefsElement;
-    querySelector(selectors: "del"): HTMLModElement;
-    querySelector(selectors: "desc"): SVGDescElement;
-    querySelector(selectors: "dfn"): HTMLElement;
-    querySelector(selectors: "dir"): HTMLDirectoryElement;
-    querySelector(selectors: "div"): HTMLDivElement;
-    querySelector(selectors: "dl"): HTMLDListElement;
-    querySelector(selectors: "dt"): HTMLElement;
-    querySelector(selectors: "ellipse"): SVGEllipseElement;
-    querySelector(selectors: "em"): HTMLElement;
-    querySelector(selectors: "embed"): HTMLEmbedElement;
-    querySelector(selectors: "feblend"): SVGFEBlendElement;
-    querySelector(selectors: "fecolormatrix"): SVGFEColorMatrixElement;
-    querySelector(selectors: "fecomponenttransfer"): SVGFEComponentTransferElement;
-    querySelector(selectors: "fecomposite"): SVGFECompositeElement;
-    querySelector(selectors: "feconvolvematrix"): SVGFEConvolveMatrixElement;
-    querySelector(selectors: "fediffuselighting"): SVGFEDiffuseLightingElement;
-    querySelector(selectors: "fedisplacementmap"): SVGFEDisplacementMapElement;
-    querySelector(selectors: "fedistantlight"): SVGFEDistantLightElement;
-    querySelector(selectors: "feflood"): SVGFEFloodElement;
-    querySelector(selectors: "fefunca"): SVGFEFuncAElement;
-    querySelector(selectors: "fefuncb"): SVGFEFuncBElement;
-    querySelector(selectors: "fefuncg"): SVGFEFuncGElement;
-    querySelector(selectors: "fefuncr"): SVGFEFuncRElement;
-    querySelector(selectors: "fegaussianblur"): SVGFEGaussianBlurElement;
-    querySelector(selectors: "feimage"): SVGFEImageElement;
-    querySelector(selectors: "femerge"): SVGFEMergeElement;
-    querySelector(selectors: "femergenode"): SVGFEMergeNodeElement;
-    querySelector(selectors: "femorphology"): SVGFEMorphologyElement;
-    querySelector(selectors: "feoffset"): SVGFEOffsetElement;
-    querySelector(selectors: "fepointlight"): SVGFEPointLightElement;
-    querySelector(selectors: "fespecularlighting"): SVGFESpecularLightingElement;
-    querySelector(selectors: "fespotlight"): SVGFESpotLightElement;
-    querySelector(selectors: "fetile"): SVGFETileElement;
-    querySelector(selectors: "feturbulence"): SVGFETurbulenceElement;
-    querySelector(selectors: "fieldset"): HTMLFieldSetElement;
-    querySelector(selectors: "figcaption"): HTMLElement;
-    querySelector(selectors: "figure"): HTMLElement;
-    querySelector(selectors: "filter"): SVGFilterElement;
-    querySelector(selectors: "font"): HTMLFontElement;
-    querySelector(selectors: "footer"): HTMLElement;
-    querySelector(selectors: "foreignobject"): SVGForeignObjectElement;
-    querySelector(selectors: "form"): HTMLFormElement;
-    querySelector(selectors: "frame"): HTMLFrameElement;
-    querySelector(selectors: "frameset"): HTMLFrameSetElement;
-    querySelector(selectors: "g"): SVGGElement;
-    querySelector(selectors: "h1"): HTMLHeadingElement;
-    querySelector(selectors: "h2"): HTMLHeadingElement;
-    querySelector(selectors: "h3"): HTMLHeadingElement;
-    querySelector(selectors: "h4"): HTMLHeadingElement;
-    querySelector(selectors: "h5"): HTMLHeadingElement;
-    querySelector(selectors: "h6"): HTMLHeadingElement;
-    querySelector(selectors: "head"): HTMLHeadElement;
-    querySelector(selectors: "header"): HTMLElement;
-    querySelector(selectors: "hgroup"): HTMLElement;
-    querySelector(selectors: "hr"): HTMLHRElement;
-    querySelector(selectors: "html"): HTMLHtmlElement;
-    querySelector(selectors: "i"): HTMLElement;
-    querySelector(selectors: "iframe"): HTMLIFrameElement;
-    querySelector(selectors: "image"): SVGImageElement;
-    querySelector(selectors: "img"): HTMLImageElement;
-    querySelector(selectors: "input"): HTMLInputElement;
-    querySelector(selectors: "ins"): HTMLModElement;
-    querySelector(selectors: "isindex"): HTMLUnknownElement;
-    querySelector(selectors: "kbd"): HTMLElement;
-    querySelector(selectors: "keygen"): HTMLElement;
-    querySelector(selectors: "label"): HTMLLabelElement;
-    querySelector(selectors: "legend"): HTMLLegendElement;
-    querySelector(selectors: "li"): HTMLLIElement;
-    querySelector(selectors: "line"): SVGLineElement;
-    querySelector(selectors: "lineargradient"): SVGLinearGradientElement;
-    querySelector(selectors: "link"): HTMLLinkElement;
-    querySelector(selectors: "listing"): HTMLPreElement;
-    querySelector(selectors: "map"): HTMLMapElement;
-    querySelector(selectors: "mark"): HTMLElement;
-    querySelector(selectors: "marker"): SVGMarkerElement;
-    querySelector(selectors: "marquee"): HTMLMarqueeElement;
-    querySelector(selectors: "mask"): SVGMaskElement;
-    querySelector(selectors: "menu"): HTMLMenuElement;
-    querySelector(selectors: "meta"): HTMLMetaElement;
-    querySelector(selectors: "metadata"): SVGMetadataElement;
-    querySelector(selectors: "meter"): HTMLMeterElement;
-    querySelector(selectors: "nav"): HTMLElement;
-    querySelector(selectors: "nextid"): HTMLUnknownElement;
-    querySelector(selectors: "nobr"): HTMLElement;
-    querySelector(selectors: "noframes"): HTMLElement;
-    querySelector(selectors: "noscript"): HTMLElement;
-    querySelector(selectors: "object"): HTMLObjectElement;
-    querySelector(selectors: "ol"): HTMLOListElement;
-    querySelector(selectors: "optgroup"): HTMLOptGroupElement;
-    querySelector(selectors: "option"): HTMLOptionElement;
-    querySelector(selectors: "p"): HTMLParagraphElement;
-    querySelector(selectors: "param"): HTMLParamElement;
-    querySelector(selectors: "path"): SVGPathElement;
-    querySelector(selectors: "pattern"): SVGPatternElement;
-    querySelector(selectors: "picture"): HTMLPictureElement;
-    querySelector(selectors: "plaintext"): HTMLElement;
-    querySelector(selectors: "polygon"): SVGPolygonElement;
-    querySelector(selectors: "polyline"): SVGPolylineElement;
-    querySelector(selectors: "pre"): HTMLPreElement;
-    querySelector(selectors: "progress"): HTMLProgressElement;
-    querySelector(selectors: "q"): HTMLQuoteElement;
-    querySelector(selectors: "radialgradient"): SVGRadialGradientElement;
-    querySelector(selectors: "rect"): SVGRectElement;
-    querySelector(selectors: "rt"): HTMLElement;
-    querySelector(selectors: "ruby"): HTMLElement;
-    querySelector(selectors: "s"): HTMLElement;
-    querySelector(selectors: "samp"): HTMLElement;
-    querySelector(selectors: "script"): HTMLScriptElement;
-    querySelector(selectors: "section"): HTMLElement;
-    querySelector(selectors: "select"): HTMLSelectElement;
-    querySelector(selectors: "small"): HTMLElement;
-    querySelector(selectors: "source"): HTMLSourceElement;
-    querySelector(selectors: "span"): HTMLSpanElement;
-    querySelector(selectors: "stop"): SVGStopElement;
-    querySelector(selectors: "strike"): HTMLElement;
-    querySelector(selectors: "strong"): HTMLElement;
-    querySelector(selectors: "style"): HTMLStyleElement;
-    querySelector(selectors: "sub"): HTMLElement;
-    querySelector(selectors: "sup"): HTMLElement;
-    querySelector(selectors: "svg"): SVGSVGElement;
-    querySelector(selectors: "switch"): SVGSwitchElement;
-    querySelector(selectors: "symbol"): SVGSymbolElement;
-    querySelector(selectors: "table"): HTMLTableElement;
-    querySelector(selectors: "tbody"): HTMLTableSectionElement;
-    querySelector(selectors: "td"): HTMLTableDataCellElement;
-    querySelector(selectors: "template"): HTMLTemplateElement;
-    querySelector(selectors: "text"): SVGTextElement;
-    querySelector(selectors: "textpath"): SVGTextPathElement;
-    querySelector(selectors: "textarea"): HTMLTextAreaElement;
-    querySelector(selectors: "tfoot"): HTMLTableSectionElement;
-    querySelector(selectors: "th"): HTMLTableHeaderCellElement;
-    querySelector(selectors: "thead"): HTMLTableSectionElement;
-    querySelector(selectors: "title"): HTMLTitleElement;
-    querySelector(selectors: "tr"): HTMLTableRowElement;
-    querySelector(selectors: "track"): HTMLTrackElement;
-    querySelector(selectors: "tspan"): SVGTSpanElement;
-    querySelector(selectors: "tt"): HTMLElement;
-    querySelector(selectors: "u"): HTMLElement;
-    querySelector(selectors: "ul"): HTMLUListElement;
-    querySelector(selectors: "use"): SVGUseElement;
-    querySelector(selectors: "var"): HTMLElement;
-    querySelector(selectors: "video"): HTMLVideoElement;
-    querySelector(selectors: "view"): SVGViewElement;
-    querySelector(selectors: "wbr"): HTMLElement;
-    querySelector(selectors: "x-ms-webview"): MSHTMLWebViewElement;
-    querySelector(selectors: "xmp"): HTMLPreElement;
-    querySelector(selectors: string): Element;
+    querySelector(selectors: "a"): HTMLAnchorElement | null;
+    querySelector(selectors: "abbr"): HTMLElement | null;
+    querySelector(selectors: "acronym"): HTMLElement | null;
+    querySelector(selectors: "address"): HTMLElement | null;
+    querySelector(selectors: "applet"): HTMLAppletElement | null;
+    querySelector(selectors: "area"): HTMLAreaElement | null;
+    querySelector(selectors: "article"): HTMLElement | null;
+    querySelector(selectors: "aside"): HTMLElement | null;
+    querySelector(selectors: "audio"): HTMLAudioElement | null;
+    querySelector(selectors: "b"): HTMLElement | null;
+    querySelector(selectors: "base"): HTMLBaseElement | null;
+    querySelector(selectors: "basefont"): HTMLBaseFontElement | null;
+    querySelector(selectors: "bdo"): HTMLElement | null;
+    querySelector(selectors: "big"): HTMLElement | null;
+    querySelector(selectors: "blockquote"): HTMLQuoteElement | null;
+    querySelector(selectors: "body"): HTMLBodyElement | null;
+    querySelector(selectors: "br"): HTMLBRElement | null;
+    querySelector(selectors: "button"): HTMLButtonElement | null;
+    querySelector(selectors: "canvas"): HTMLCanvasElement | null;
+    querySelector(selectors: "caption"): HTMLTableCaptionElement | null;
+    querySelector(selectors: "center"): HTMLElement | null;
+    querySelector(selectors: "circle"): SVGCircleElement | null;
+    querySelector(selectors: "cite"): HTMLElement | null;
+    querySelector(selectors: "clippath"): SVGClipPathElement | null;
+    querySelector(selectors: "code"): HTMLElement | null;
+    querySelector(selectors: "col"): HTMLTableColElement | null;
+    querySelector(selectors: "colgroup"): HTMLTableColElement | null;
+    querySelector(selectors: "datalist"): HTMLDataListElement | null;
+    querySelector(selectors: "dd"): HTMLElement | null;
+    querySelector(selectors: "defs"): SVGDefsElement | null;
+    querySelector(selectors: "del"): HTMLModElement | null;
+    querySelector(selectors: "desc"): SVGDescElement | null;
+    querySelector(selectors: "dfn"): HTMLElement | null;
+    querySelector(selectors: "dir"): HTMLDirectoryElement | null;
+    querySelector(selectors: "div"): HTMLDivElement | null;
+    querySelector(selectors: "dl"): HTMLDListElement | null;
+    querySelector(selectors: "dt"): HTMLElement | null;
+    querySelector(selectors: "ellipse"): SVGEllipseElement | null;
+    querySelector(selectors: "em"): HTMLElement | null;
+    querySelector(selectors: "embed"): HTMLEmbedElement | null;
+    querySelector(selectors: "feblend"): SVGFEBlendElement | null;
+    querySelector(selectors: "fecolormatrix"): SVGFEColorMatrixElement | null;
+    querySelector(selectors: "fecomponenttransfer"): SVGFEComponentTransferElement | null;
+    querySelector(selectors: "fecomposite"): SVGFECompositeElement | null;
+    querySelector(selectors: "feconvolvematrix"): SVGFEConvolveMatrixElement | null;
+    querySelector(selectors: "fediffuselighting"): SVGFEDiffuseLightingElement | null;
+    querySelector(selectors: "fedisplacementmap"): SVGFEDisplacementMapElement | null;
+    querySelector(selectors: "fedistantlight"): SVGFEDistantLightElement | null;
+    querySelector(selectors: "feflood"): SVGFEFloodElement | null;
+    querySelector(selectors: "fefunca"): SVGFEFuncAElement | null;
+    querySelector(selectors: "fefuncb"): SVGFEFuncBElement | null;
+    querySelector(selectors: "fefuncg"): SVGFEFuncGElement | null;
+    querySelector(selectors: "fefuncr"): SVGFEFuncRElement | null;
+    querySelector(selectors: "fegaussianblur"): SVGFEGaussianBlurElement | null;
+    querySelector(selectors: "feimage"): SVGFEImageElement | null;
+    querySelector(selectors: "femerge"): SVGFEMergeElement | null;
+    querySelector(selectors: "femergenode"): SVGFEMergeNodeElement | null;
+    querySelector(selectors: "femorphology"): SVGFEMorphologyElement | null;
+    querySelector(selectors: "feoffset"): SVGFEOffsetElement | null;
+    querySelector(selectors: "fepointlight"): SVGFEPointLightElement | null;
+    querySelector(selectors: "fespecularlighting"): SVGFESpecularLightingElement | null;
+    querySelector(selectors: "fespotlight"): SVGFESpotLightElement | null;
+    querySelector(selectors: "fetile"): SVGFETileElement | null;
+    querySelector(selectors: "feturbulence"): SVGFETurbulenceElement | null;
+    querySelector(selectors: "fieldset"): HTMLFieldSetElement | null;
+    querySelector(selectors: "figcaption"): HTMLElement | null;
+    querySelector(selectors: "figure"): HTMLElement | null;
+    querySelector(selectors: "filter"): SVGFilterElement | null;
+    querySelector(selectors: "font"): HTMLFontElement | null;
+    querySelector(selectors: "footer"): HTMLElement | null;
+    querySelector(selectors: "foreignobject"): SVGForeignObjectElement | null;
+    querySelector(selectors: "form"): HTMLFormElement | null;
+    querySelector(selectors: "frame"): HTMLFrameElement | null;
+    querySelector(selectors: "frameset"): HTMLFrameSetElement | null;
+    querySelector(selectors: "g"): SVGGElement | null;
+    querySelector(selectors: "h1"): HTMLHeadingElement | null;
+    querySelector(selectors: "h2"): HTMLHeadingElement | null;
+    querySelector(selectors: "h3"): HTMLHeadingElement | null;
+    querySelector(selectors: "h4"): HTMLHeadingElement | null;
+    querySelector(selectors: "h5"): HTMLHeadingElement | null;
+    querySelector(selectors: "h6"): HTMLHeadingElement | null;
+    querySelector(selectors: "head"): HTMLHeadElement | null;
+    querySelector(selectors: "header"): HTMLElement | null;
+    querySelector(selectors: "hgroup"): HTMLElement | null;
+    querySelector(selectors: "hr"): HTMLHRElement | null;
+    querySelector(selectors: "html"): HTMLHtmlElement | null;
+    querySelector(selectors: "i"): HTMLElement | null;
+    querySelector(selectors: "iframe"): HTMLIFrameElement | null;
+    querySelector(selectors: "image"): SVGImageElement | null;
+    querySelector(selectors: "img"): HTMLImageElement | null;
+    querySelector(selectors: "input"): HTMLInputElement | null;
+    querySelector(selectors: "ins"): HTMLModElement | null;
+    querySelector(selectors: "isindex"): HTMLUnknownElement | null;
+    querySelector(selectors: "kbd"): HTMLElement | null;
+    querySelector(selectors: "keygen"): HTMLElement | null;
+    querySelector(selectors: "label"): HTMLLabelElement | null;
+    querySelector(selectors: "legend"): HTMLLegendElement | null;
+    querySelector(selectors: "li"): HTMLLIElement | null;
+    querySelector(selectors: "line"): SVGLineElement | null;
+    querySelector(selectors: "lineargradient"): SVGLinearGradientElement | null;
+    querySelector(selectors: "link"): HTMLLinkElement | null;
+    querySelector(selectors: "listing"): HTMLPreElement | null;
+    querySelector(selectors: "map"): HTMLMapElement | null;
+    querySelector(selectors: "mark"): HTMLElement | null;
+    querySelector(selectors: "marker"): SVGMarkerElement | null;
+    querySelector(selectors: "marquee"): HTMLMarqueeElement | null;
+    querySelector(selectors: "mask"): SVGMaskElement | null;
+    querySelector(selectors: "menu"): HTMLMenuElement | null;
+    querySelector(selectors: "meta"): HTMLMetaElement | null;
+    querySelector(selectors: "metadata"): SVGMetadataElement | null;
+    querySelector(selectors: "meter"): HTMLMeterElement | null;
+    querySelector(selectors: "nav"): HTMLElement | null;
+    querySelector(selectors: "nextid"): HTMLUnknownElement | null;
+    querySelector(selectors: "nobr"): HTMLElement | null;
+    querySelector(selectors: "noframes"): HTMLElement | null;
+    querySelector(selectors: "noscript"): HTMLElement | null;
+    querySelector(selectors: "object"): HTMLObjectElement | null;
+    querySelector(selectors: "ol"): HTMLOListElement | null;
+    querySelector(selectors: "optgroup"): HTMLOptGroupElement | null;
+    querySelector(selectors: "option"): HTMLOptionElement | null;
+    querySelector(selectors: "p"): HTMLParagraphElement | null;
+    querySelector(selectors: "param"): HTMLParamElement | null;
+    querySelector(selectors: "path"): SVGPathElement | null;
+    querySelector(selectors: "pattern"): SVGPatternElement | null;
+    querySelector(selectors: "picture"): HTMLPictureElement | null;
+    querySelector(selectors: "plaintext"): HTMLElement | null;
+    querySelector(selectors: "polygon"): SVGPolygonElement | null;
+    querySelector(selectors: "polyline"): SVGPolylineElement | null;
+    querySelector(selectors: "pre"): HTMLPreElement | null;
+    querySelector(selectors: "progress"): HTMLProgressElement | null;
+    querySelector(selectors: "q"): HTMLQuoteElement | null;
+    querySelector(selectors: "radialgradient"): SVGRadialGradientElement | null;
+    querySelector(selectors: "rect"): SVGRectElement | null;
+    querySelector(selectors: "rt"): HTMLElement | null;
+    querySelector(selectors: "ruby"): HTMLElement | null;
+    querySelector(selectors: "s"): HTMLElement | null;
+    querySelector(selectors: "samp"): HTMLElement | null;
+    querySelector(selectors: "script"): HTMLScriptElement | null;
+    querySelector(selectors: "section"): HTMLElement | null;
+    querySelector(selectors: "select"): HTMLSelectElement | null;
+    querySelector(selectors: "small"): HTMLElement | null;
+    querySelector(selectors: "source"): HTMLSourceElement | null;
+    querySelector(selectors: "span"): HTMLSpanElement | null;
+    querySelector(selectors: "stop"): SVGStopElement | null;
+    querySelector(selectors: "strike"): HTMLElement | null;
+    querySelector(selectors: "strong"): HTMLElement | null;
+    querySelector(selectors: "style"): HTMLStyleElement | null;
+    querySelector(selectors: "sub"): HTMLElement | null;
+    querySelector(selectors: "sup"): HTMLElement | null;
+    querySelector(selectors: "svg"): SVGSVGElement | null;
+    querySelector(selectors: "switch"): SVGSwitchElement | null;
+    querySelector(selectors: "symbol"): SVGSymbolElement | null;
+    querySelector(selectors: "table"): HTMLTableElement | null;
+    querySelector(selectors: "tbody"): HTMLTableSectionElement | null;
+    querySelector(selectors: "td"): HTMLTableDataCellElement | null;
+    querySelector(selectors: "template"): HTMLTemplateElement | null;
+    querySelector(selectors: "text"): SVGTextElement | null;
+    querySelector(selectors: "textpath"): SVGTextPathElement | null;
+    querySelector(selectors: "textarea"): HTMLTextAreaElement | null;
+    querySelector(selectors: "tfoot"): HTMLTableSectionElement | null;
+    querySelector(selectors: "th"): HTMLTableHeaderCellElement | null;
+    querySelector(selectors: "thead"): HTMLTableSectionElement | null;
+    querySelector(selectors: "title"): HTMLTitleElement | null;
+    querySelector(selectors: "tr"): HTMLTableRowElement | null;
+    querySelector(selectors: "track"): HTMLTrackElement | null;
+    querySelector(selectors: "tspan"): SVGTSpanElement | null;
+    querySelector(selectors: "tt"): HTMLElement | null;
+    querySelector(selectors: "u"): HTMLElement | null;
+    querySelector(selectors: "ul"): HTMLUListElement | null;
+    querySelector(selectors: "use"): SVGUseElement | null;
+    querySelector(selectors: "var"): HTMLElement | null;
+    querySelector(selectors: "video"): HTMLVideoElement | null;
+    querySelector(selectors: "view"): SVGViewElement | null;
+    querySelector(selectors: "wbr"): HTMLElement | null;
+    querySelector(selectors: "x-ms-webview"): MSHTMLWebViewElement | null;
+    querySelector(selectors: "xmp"): HTMLPreElement | null;
+    querySelector(selectors: string): Element | null;
     querySelectorAll(selectors: "a"): NodeListOf<HTMLAnchorElement>;
     querySelectorAll(selectors: "abbr"): NodeListOf<HTMLElement>;
     querySelectorAll(selectors: "acronym"): NodeListOf<HTMLElement>;
@@ -14045,6 +14059,20 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+interface ScrollOptions {
+    behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+    left?: number;
+    top?: number;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+}
+
 interface ClipboardEventInit extends EventInit {
     data?: string;
     dataType?: string;
@@ -14088,7 +14116,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
@@ -14224,6 +14252,13 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface ParentNode {
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    readonly childElementCount: number;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -14294,7 +14329,7 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msCredentials: MSCredentials;
-declare var name: string;
+declare const name: never;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
 declare var onabort: (this: Window, ev: UIEvent) => any;
@@ -14388,7 +14423,7 @@ declare var ontouchstart: (ev: TouchEvent) => any;
 declare var onunload: (this: Window, ev: Event) => any;
 declare var onvolumechange: (this: Window, ev: Event) => any;
 declare var onwaiting: (this: Window, ev: Event) => any;
-declare var opener: Window;
+declare var opener: any;
 declare var orientation: string | number;
 declare var outerHeight: number;
 declare var outerWidth: number;
@@ -14441,6 +14476,9 @@ declare function webkitCancelAnimationFrame(handle: number): void;
 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function scroll(options?: ScrollToOptions): void;
+declare function scrollTo(options?: ScrollToOptions): void;
+declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 declare function dispatchEvent(evt: Event): boolean;
@@ -14596,6 +14634,9 @@ type MSOutboundPayload = MSVideoSendPayload | MSAudioSendPayload;
 type RTCIceGatherCandidate = RTCIceCandidate | RTCIceCandidateComplete;
 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
 type payloadtype = number;
+type ScrollBehavior = "auto" | "instant" | "smooth";
+type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
-type MouseWheelEvent = WheelEvent;
+type MouseWheelEvent = WheelEvent;
+type ScrollRestoration = "auto" | "manual";

lib/lib.dom.iterable.d.ts

@@ -14,7 +14,7 @@ and limitations under the License.
 ***************************************************************************** */
 
 /// <reference no-default-lib="true"/>
-/// <reference path="lib.dom.generated.d.ts" />
+/// <reference path="lib.dom.d.ts" />
 
 interface DOMTokenList {
     [Symbol.iterator](): IterableIterator<string>;

lib/lib.es2015.collection.d.ts

@@ -17,7 +17,7 @@ and limitations under the License.
 interface Map<K, V> {
     clear(): void;
     delete(key: K): boolean;
-    forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
     set(key: K, value?: V): this;
@@ -31,8 +31,14 @@ interface MapConstructor {
 }
 declare var Map: MapConstructor;
 
+interface ReadonlyMap<K, V> {
+    forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void;
+    get(key: K): V|undefined;
+    has(key: K): boolean;
+    readonly size: number;
+}
+
 interface WeakMap<K, V> {
-    clear(): void;
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;
@@ -50,7 +56,7 @@ interface Set<T> {
     add(value: T): this;
     clear(): void;
     delete(value: T): boolean;
-    forEach(callbackfn: (value: T, index: T, set: Set<T>) => void, thisArg?: any): void;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
     has(value: T): boolean;
     readonly size: number;
 }
@@ -62,9 +68,14 @@ interface SetConstructor {
 }
 declare var Set: SetConstructor;
 
+interface ReadonlySet<T> {
+    forEach(callbackfn: (value: T, value2: T, set: ReadonlySet<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+}
+
 interface WeakSet<T> {
     add(value: T): this;
-    clear(): void;
     delete(value: T): boolean;
     has(value: T): boolean;
 }

lib/lib.es2015.core.d.ts

@@ -29,15 +29,15 @@ interface Array<T> {
     find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
-      * order, until it finds one where predicate returns true. If such an element is found, 
+      * order, until it finds one where predicate returns true. If such an element is found,
       * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): number;
 
     /**
       * Returns the this object after filling the section identified by start and end with value
@@ -84,6 +84,10 @@ interface ArrayConstructor {
     of<T>(...items: T[]): Array<T>;
 }
 
+interface DateConstructor {
+    new (value: Date): Date;
+}
+
 interface Function {
     /**
       * Returns the name of the function. Function names are read-only and can not be changed.
@@ -213,7 +217,7 @@ interface NumberConstructor {
 
     /**
       * Returns true if passed value is finite.
-      * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
+      * Unlike the global isFinite, Number.isFinite doesn't forcibly convert the parameter to a
       * number. Only finite values of the type number, result in true.
       * @param number A numeric value.
       */
@@ -242,7 +246,7 @@ interface NumberConstructor {
     /**
       * The value of the largest integer n such that n and n + 1 are both exactly representable as
       * a Number value.
-      * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
+      * The value of Number.MAX_SAFE_INTEGER is 9007199254740991 2^53 − 1.
       */
     readonly MAX_SAFE_INTEGER: number;
 
@@ -359,6 +363,30 @@ interface ObjectConstructor {
     defineProperty(o: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): any;
 }
 
+interface ReadonlyArray<T> {
+  /**
+    * Returns the value of the first element in the array where predicate is true, and undefined
+    * otherwise.
+    * @param predicate find calls predicate once for each element of the array, in ascending
+    * order, until it finds one where predicate returns true. If such an element is found, find
+    * immediately returns that element value. Otherwise, find returns undefined.
+    * @param thisArg If provided, it will be used as the this value for each invocation of
+    * predicate. If it is not provided, undefined is used instead.
+    */
+  find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): T | undefined;
+
+  /**
+    * Returns the index of the first element in the array where predicate is true, and -1
+    * otherwise.
+    * @param predicate find calls predicate once for each element of the array, in ascending
+    * order, until it finds one where predicate returns true. If such an element is found,
+    * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+    * @param thisArg If provided, it will be used as the this value for each invocation of
+    * predicate. If it is not provided, undefined is used instead.
+    */
+  findIndex(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): number;
+}
+
 interface RegExp {
     /**
       * Returns a string indicating the flags of the regular expression in question. This field is read-only.

lib/lib.es2015.iterable.d.ts

@@ -79,6 +79,26 @@ interface ArrayConstructor {
     from<T>(iterable: Iterable<T>): Array<T>;
 }
 
+interface ReadonlyArray<T> {
+    /** Iterator */
+    [Symbol.iterator](): IterableIterator<T>;
+
+    /** 
+      * Returns an array of key, value pairs for every entry in the array
+      */
+    entries(): IterableIterator<[number, T]>;
+
+    /** 
+      * Returns an list of keys in the array
+      */
+    keys(): IterableIterator<number>;
+
+    /** 
+      * Returns an list of values in the array
+      */
+    values(): IterableIterator<T>;
+}
+
 interface IArguments {
     /** Iterator */
     [Symbol.iterator](): IterableIterator<any>;

lib/lib.es2015.promise.d.ts

@@ -24,7 +24,7 @@ interface Promise<T> {
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+    then(onfulfilled?: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): Promise<T>;
 
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
@@ -32,20 +32,30 @@ interface Promise<T> {
      * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>;
+    then<TResult>(onfulfilled: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
 
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
      * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
      * @returns A Promise for the completion of which ever callback is executed.
      */
-    then<TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>): Promise<TResult>;
+    then<TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
 
     /**
-     * Creates a new Promise with the same internal state of this Promise.
-     * @returns A Promise.
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
      */
-    then(): Promise<T>;
+    then<TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch(onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): Promise<T>;
 
     /**
      * Attaches a callback for only the rejection of the Promise.
@@ -53,13 +63,6 @@ interface Promise<T> {
      * @returns A Promise for the completion of the callback.
      */
     catch<TResult>(onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
-
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of the callback.
-     */
-    catch(onrejected: (reason: any) => T | PromiseLike<T>): Promise<T>;
 }
 
 interface PromiseConstructor {
@@ -156,6 +159,86 @@ interface PromiseConstructor {
      */
     all<T>(values: (T | PromiseLike<T>)[]): Promise<T[]>;
 
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>, T10 | PromiseLike<T10>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9 | T10>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>, T9 | PromiseLike<T9>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>, T8 | PromiseLike<T8>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>, T7 | PromiseLike<T7>]): Promise<T1 | T2 | T3 | T4 | T5 | T6 | T7>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4, T5, T6>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>, T6 | PromiseLike<T6>]): Promise<T1 | T2 | T3 | T4 | T5 | T6>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4, T5>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>, T5 | PromiseLike<T5>]): Promise<T1 | T2 | T3 | T4 | T5>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3, T4>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]): Promise<T1 | T2 | T3 | T4>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2, T3>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]): Promise<T1 | T2 | T3>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T1, T2>(values: [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]): Promise<T1 | T2>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T>(values: (T | PromiseLike<T>)[]): Promise<T>;
+
     /**
      * Creates a new rejected promise for the provided reason.
      * @param reason The reason the promise was rejected.

lib/lib.es2015.reflect.d.ts

@@ -22,8 +22,7 @@ declare namespace Reflect {
     function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
     function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
     function getPrototypeOf(target: any): any;
-    function has(target: any, propertyKey: string): boolean;
-    function has(target: any, propertyKey: symbol): boolean;
+    function has(target: any, propertyKey: PropertyKey): boolean;
     function isExtensible(target: any): boolean;
     function ownKeys(target: any): Array<PropertyKey>;
     function preventExtensions(target: any): boolean;

lib/lib.es5.d.ts

@@ -260,6 +260,9 @@ interface Function {
       */
     bind(this: Function, thisArg: any, ...argArray: any[]): any;
 
+    /** Returns a string representation of a function. */
+    toString(): string;
+
     prototype: any;
     readonly length: number;
 
@@ -529,8 +532,8 @@ interface NumberConstructor {
 /** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */
 declare const Number: NumberConstructor;
 
-interface TemplateStringsArray extends Array<string> {
-    readonly raw: string[];
+interface TemplateStringsArray extends ReadonlyArray<string> {
+    readonly raw: ReadonlyArray<string>
 }
 
 interface Math {
@@ -1022,7 +1025,12 @@ interface ReadonlyArray<T> {
       * Combines two or more arrays.
       * @param items Additional items to add to the end of array1.
       */
-    concat(...items: T[]): T[];
+    concat(...items: T[][]): T[];
+    /**
+      * Combines two or more arrays.
+      * @param items Additional items to add to the end of array1.
+      */
+    concat(...items: (T | T[])[]): T[];
     /**
       * Adds all the elements of an array separated by the specified separator string.
       * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
@@ -1071,6 +1079,12 @@ interface ReadonlyArray<T> {
       * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     map<U>(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => U, thisArg?: any): U[];
+    /**
+     * Returns the elements of an array that meet the condition specified in a callback function.
+     * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
+     * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+     */
+    filter<S extends T>(callbackfn: (value: T, index: number, array: ReadonlyArray<T>) => value is S, thisArg?: any): S[];
     /**
       * Returns the elements of an array that meet the condition specified in a callback function.
       * @param callbackfn A function that accepts up to three arguments. The filter method calls the callbackfn function one time for each element in the array.
@@ -1124,6 +1138,11 @@ interface Array<T> {
       * Removes the last element from an array and returns it.
       */
     pop(): T | undefined;
+    /**
+      * Combines two or more arrays.
+      * @param items Additional items to add to the end of array1.
+      */
+    concat(...items: T[][]): T[];
     /**
       * Combines two or more arrays.
       * @param items Additional items to add to the end of array1.
@@ -1200,6 +1219,30 @@ interface Array<T> {
       * @param thisArg  An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
       */
     forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+    /**
+      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    map<U>(this: [T, T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U, U];
+    /**
+      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    map<U>(this: [T, T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U, U];
+    /**
+      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    map<U>(this: [T, T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U, U];
+    /**
+      * Calls a defined callback function on each element of an array, and returns an array that contains the results.
+      * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
+      * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
+      */
+    map<U>(this: [T, T], callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): [U, U];
     /**
       * Calls a defined callback function on each element of an array, and returns an array that contains the results.
       * @param callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
@@ -1271,13 +1314,44 @@ declare type PromiseConstructorLike = new <T>(executor: (resolve: (value?: T | P
 
 interface PromiseLike<T> {
     /**
-    * Attaches callbacks for the resolution and/or rejection of the Promise.
-    * @param onfulfilled The callback to execute when the Promise is resolved.
-    * @param onrejected The callback to execute when the Promise is rejected.
-    * @returns A Promise for the completion of which ever callback is executed.
-    */
-    then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>;
-    then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then(
+        onfulfilled?: ((value: T) => T | PromiseLike<T>) | undefined | null,
+        onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): PromiseLike<T>;
+
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult>(
+        onfulfilled: ((value: T) => T | PromiseLike<T>) | undefined | null,
+        onrejected: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<T | TResult>;
+
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult>(
+        onfulfilled: (value: T) => TResult | PromiseLike<TResult>,
+        onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): PromiseLike<TResult>;
+
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1, TResult2>(
+        onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>,
+        onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
 }
 
 interface ArrayLike<T> {
@@ -1537,7 +1611,7 @@ interface Int8Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -1545,7 +1619,7 @@ interface Int8Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -1810,7 +1884,7 @@ interface Uint8Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -1818,7 +1892,7 @@ interface Uint8Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2084,7 +2158,7 @@ interface Uint8ClampedArray {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -2092,7 +2166,7 @@ interface Uint8ClampedArray {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2357,7 +2431,7 @@ interface Int16Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -2365,7 +2439,7 @@ interface Int16Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2631,7 +2705,7 @@ interface Uint16Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -2639,7 +2713,7 @@ interface Uint16Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -2904,7 +2978,7 @@ interface Int32Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -2912,7 +2986,7 @@ interface Int32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3177,7 +3251,7 @@ interface Uint32Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -3185,7 +3259,7 @@ interface Uint32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3450,7 +3524,7 @@ interface Float32Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -3458,7 +3532,7 @@ interface Float32Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3724,7 +3798,7 @@ interface Float64Array {
     find(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number | undefined;
 
     /**
-      * Returns the index of the first element in the array where predicate is true, and undefined
+      * Returns the index of the first element in the array where predicate is true, and -1
       * otherwise.
       * @param predicate find calls predicate once for each element of the array, in ascending
       * order, until it finds one where predicate returns true. If such an element is found,
@@ -3732,7 +3806,7 @@ interface Float64Array {
       * @param thisArg If provided, it will be used as the this value for each invocation of
       * predicate. If it is not provided, undefined is used instead.
       */
-    findIndex(predicate: (value: number) => boolean, thisArg?: any): number;
+    findIndex(predicate: (value: number, index: number, obj: Array<number>) => boolean, thisArg?: any): number;
 
     /**
       * Performs the specified action for each element in an array.
@@ -3949,12 +4023,9 @@ declare module Intl {
         resolvedOptions(): ResolvedCollatorOptions;
     }
     var Collator: {
-        new (locales?: string[], options?: CollatorOptions): Collator;
-        new (locale?: string, options?: CollatorOptions): Collator;
-        (locales?: string[], options?: CollatorOptions): Collator;
-        (locale?: string, options?: CollatorOptions): Collator;
-        supportedLocalesOf(locales: string[], options?: CollatorOptions): string[];
-        supportedLocalesOf(locale: string, options?: CollatorOptions): string[];
+        new (locales?: string | string[], options?: CollatorOptions): Collator;
+        (locales?: string | string[], options?: CollatorOptions): Collator;
+        supportedLocalesOf(locales: string | string[], options?: CollatorOptions): string[];
     }
 
     interface NumberFormatOptions {
@@ -3989,12 +4060,9 @@ declare module Intl {
         resolvedOptions(): ResolvedNumberFormatOptions;
     }
     var NumberFormat: {
-        new (locales?: string[], options?: NumberFormatOptions): NumberFormat;
-        new (locale?: string, options?: NumberFormatOptions): NumberFormat;
-        (locales?: string[], options?: NumberFormatOptions): NumberFormat;
-        (locale?: string, options?: NumberFormatOptions): NumberFormat;
-        supportedLocalesOf(locales: string[], options?: NumberFormatOptions): string[];
-        supportedLocalesOf(locale: string, options?: NumberFormatOptions): string[];
+        new (locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
+        (locales?: string | string[], options?: NumberFormatOptions): NumberFormat;
+        supportedLocalesOf(locales: string | string[], options?: NumberFormatOptions): string[];
     }
 
     interface DateTimeFormatOptions {
@@ -4035,88 +4103,49 @@ declare module Intl {
         resolvedOptions(): ResolvedDateTimeFormatOptions;
     }
     var DateTimeFormat: {
-        new (locales?: string[], options?: DateTimeFormatOptions): DateTimeFormat;
-        new (locale?: string, options?: DateTimeFormatOptions): DateTimeFormat;
-        (locales?: string[], options?: DateTimeFormatOptions): DateTimeFormat;
-        (locale?: string, options?: DateTimeFormatOptions): DateTimeFormat;
-        supportedLocalesOf(locales: string[], options?: DateTimeFormatOptions): string[];
-        supportedLocalesOf(locale: string, options?: DateTimeFormatOptions): string[];
+        new (locales?: string | string[], options?: DateTimeFormatOptions): DateTimeFormat;
+        (locales?: string | string[], options?: DateTimeFormatOptions): DateTimeFormat;
+        supportedLocalesOf(locales: string | string[], options?: DateTimeFormatOptions): string[];
     }
 }
 
 interface String {
     /**
-      * Determines whether two strings are equivalent in the current locale.
+      * Determines whether two strings are equivalent in the current or specified locale.
       * @param that String to compare to target string
-      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used. This parameter must conform to BCP 47 standards; see the Intl.Collator object for details.
+      * @param locales A locale string or array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used. This parameter must conform to BCP 47 standards; see the Intl.Collator object for details.
       * @param options An object that contains one or more properties that specify comparison options. see the Intl.Collator object for details.
       */
-    localeCompare(that: string, locales: string[], options?: Intl.CollatorOptions): number;
-
-    /**
-      * Determines whether two strings are equivalent in the current locale.
-      * @param that String to compare to target string
-      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used. This parameter must conform to BCP 47 standards; see the Intl.Collator object for details.
-      * @param options An object that contains one or more properties that specify comparison options. see the Intl.Collator object for details.
-      */
-    localeCompare(that: string, locale: string, options?: Intl.CollatorOptions): number;
+    localeCompare(that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
 }
 
 interface Number {
     /**
       * Converts a number to a string by using the current or specified locale.
-      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param locales A locale string or array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locales?: string[], options?: Intl.NumberFormatOptions): string;
-
-    /**
-      * Converts a number to a string by using the current or specified locale.
-      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
-      * @param options An object that contains one or more properties that specify comparison options.
-      */
-    toLocaleString(locale?: string, options?: Intl.NumberFormatOptions): string;
+    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions): string;
 }
 
 interface Date {
     /**
       * Converts a date and time to a string by using the current or specified locale.
-      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param locales A locale string or array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
     /**
       * Converts a date to a string by using the current or specified locale.
-      * @param locales An array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param locales A locale string or array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleDateString(locales?: string[], options?: Intl.DateTimeFormatOptions): string;
+    toLocaleDateString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
 
     /**
       * Converts a time to a string by using the current or specified locale.
-      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
+      * @param locales A locale string or array of locale strings that contain one or more language or locale tags. If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
       * @param options An object that contains one or more properties that specify comparison options.
       */
-    toLocaleTimeString(locale?: string[], options?: Intl.DateTimeFormatOptions): string;
-
-    /**
-      * Converts a date and time to a string by using the current or specified locale.
-      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
-      * @param options An object that contains one or more properties that specify comparison options.
-      */
-    toLocaleString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
-
-    /**
-      * Converts a date to a string by using the current or specified locale.
-      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
-      * @param options An object that contains one or more properties that specify comparison options.
-      */
-    toLocaleDateString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
-
-    /**
-      * Converts a time to a string by using the current or specified locale.
-      * @param locale Locale tag. If you omit this parameter, the default locale of the JavaScript runtime is used.
-      * @param options An object that contains one or more properties that specify comparison options.
-      */
-    toLocaleTimeString(locale?: string, options?: Intl.DateTimeFormatOptions): string;
+    toLocaleTimeString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
 }

lib/lib.webworker.d.ts

@@ -744,7 +744,7 @@ declare var Worker: {
 }
 
 interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
-    onreadystatechange: (this: this, ev: ProgressEvent) => any;
+    onreadystatechange: (this: this, ev: Event) => any;
     readonly readyState: number;
     readonly response: any;
     readonly responseText: string;
@@ -770,13 +770,13 @@ interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
     readonly LOADING: number;
     readonly OPENED: number;
     readonly UNSENT: number;
-    addEventListener(type: "abort", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
-    addEventListener(type: "error", listener: (this: this, ev: ErrorEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "load", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "abort", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "error", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "load", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "loadend", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "loadstart", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
+    addEventListener(type: "loadstart", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "progress", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "readystatechange", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
+    addEventListener(type: "readystatechange", listener: (this: this, ev: Event) => any, useCapture?: boolean): void;
     addEventListener(type: "timeout", listener: (this: this, ev: ProgressEvent) => any, useCapture?: boolean): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
@@ -1016,7 +1016,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {

package.json

@@ -75,6 +75,7 @@
         "through2": "latest",
         "travis-fold": "latest",
         "ts-node": "latest",
+        "tsd": "latest",
         "tslint": "next",
         "typescript": "next"
     },

scripts/browserify-optional.js

@@ -0,0 +1,24 @@
+// simple script to optionally elide source-map-support (or other optional modules) when running browserify.
+
+var stream = require("stream"),
+    Transform = stream.Transform,
+    resolve = require("browser-resolve");
+
+var requirePattern = /require\s*\(\s*['"](source-map-support)['"]\s*\)/;
+module.exports = function (file) {
+    return new Transform({
+        transform: function (data, encoding, cb) {
+            var text = encoding === "buffer" ? data.toString("utf8") : data;
+            this.push(new Buffer(text.replace(requirePattern, function (originalText, moduleName) {
+                try {
+                    resolve.sync(moduleName, { filename: file });
+                    return originalText;
+                }
+                catch (e) {
+                    return "(function () { throw new Error(\"module '" + moduleName + "' not found.\"); })()";
+                }
+            }), "utf8"));
+            cb();
+        }
+    });
+};

scripts/buildProtocol.ts

@@ -0,0 +1,150 @@
+/// <reference types="node"/>
+
+import * as ts from "../lib/typescript";
+import * as path from "path";
+
+function endsWith(s: string, suffix: string) {
+    return s.lastIndexOf(suffix, s.length - suffix.length) !== -1;
+}
+
+class DeclarationsWalker {
+    private visitedTypes: ts.Type[] = [];
+    private text = "";
+    private constructor(private typeChecker: ts.TypeChecker, private protocolFile: ts.SourceFile) {
+    }
+
+    static getExtraDeclarations(typeChecker: ts.TypeChecker, protocolFile: ts.SourceFile): string {
+        let text = "declare namespace ts.server.protocol {\n";
+        var walker = new DeclarationsWalker(typeChecker, protocolFile);
+        walker.visitTypeNodes(protocolFile);
+        return walker.text 
+            ? `declare namespace ts.server.protocol {\n${walker.text}}`
+            : "";
+    }
+
+    private processType(type: ts.Type): void {
+        if (this.visitedTypes.indexOf(type) >= 0) {
+            return;
+        }
+        this.visitedTypes.push(type);
+        let s = type.aliasSymbol || type.getSymbol();
+        if (!s) {
+            return;
+        }
+        if (s.name === "Array") {
+            // we should process type argument instead
+            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;
+                }
+                // splice declaration in final d.ts file
+                let text = decl.getFullText();
+                if (decl.kind === ts.SyntaxKind.EnumDeclaration && !(decl.flags & ts.NodeFlags.Const)) {
+                    // patch enum declaration to make them constan
+                    const declStart = decl.getStart() - decl.getFullStart();
+                    const prefix = text.substring(0, declStart);
+                    const suffix = text.substring(declStart + "enum".length, decl.getEnd() - decl.getFullStart());
+                    text = prefix + "const enum" + suffix;
+                }
+                this.text += `${text}\n`;
+
+                // recursively pull all dependencies into result dts file
+                this.visitTypeNodes(decl);
+            }
+        }
+    }
+
+    private visitTypeNodes(node: ts.Node) {
+        if (node.parent) {
+            switch (node.parent.kind) {
+                case ts.SyntaxKind.VariableDeclaration:
+                case ts.SyntaxKind.MethodDeclaration:
+                case ts.SyntaxKind.MethodSignature:
+                case ts.SyntaxKind.PropertyDeclaration:
+                case ts.SyntaxKind.PropertySignature:
+                case ts.SyntaxKind.Parameter:
+                case ts.SyntaxKind.IndexSignature:
+                    if (((<ts.VariableDeclaration | ts.MethodDeclaration | ts.PropertyDeclaration | ts.ParameterDeclaration | ts.PropertySignature | ts.MethodSignature | ts.IndexSignatureDeclaration>node.parent).type) === node) {
+                        const type = this.typeChecker.getTypeAtLocation(node);
+                        if (type && !(type.flags & ts.TypeFlags.TypeParameter)) {
+                            this.processType(type);
+                        }
+                    }
+                    break;
+            }
+        }
+        ts.forEachChild(node, n => this.visitTypeNodes(n));
+    } 
+}
+
+function generateProtocolFile(protocolTs: string, typeScriptServicesDts: string): string {
+    const options = { target: ts.ScriptTarget.ES5, declaration: true, noResolve: true, types: <string[]>[], stripInternal: true };
+
+    /**
+     * 1st pass - generate a program from protocol.ts and typescriptservices.d.ts and emit core version of protocol.d.ts with all internal members stripped
+     * @return text of protocol.d.t.s
+     */
+    function getInitialDtsFileForProtocol() {
+        const program = ts.createProgram([protocolTs, typeScriptServicesDts], options);
+
+        let protocolDts: string;
+        program.emit(program.getSourceFile(protocolTs), (file, content) => {
+            if (endsWith(file, ".d.ts")) {
+                protocolDts = content;
+            }
+        });
+        if (protocolDts === undefined) {
+            throw new Error(`Declaration file for protocol.ts is not generated`)
+        }
+        return protocolDts;
+    }
+
+    const protocolFileName = "protocol.d.ts";
+    /**
+     * Second pass - generate a program from protocol.d.ts and typescriptservices.d.ts, then augment core protocol.d.ts with extra types from typescriptservices.d.ts
+     */
+    function getProgramWithProtocolText(protocolDts: string, includeTypeScriptServices: boolean) {
+        const host = ts.createCompilerHost(options);
+        const originalGetSourceFile = host.getSourceFile;
+        host.getSourceFile = (fileName) => {
+            if (fileName === protocolFileName) {
+                return ts.createSourceFile(fileName, protocolDts, options.target);
+            }
+            return originalGetSourceFile.apply(host, [fileName]);
+        }
+        const rootFiles = includeTypeScriptServices ? [protocolFileName, typeScriptServicesDts] : [protocolFileName];
+        return ts.createProgram(rootFiles, options, host);
+    }
+
+    let protocolDts = getInitialDtsFileForProtocol();
+    const program = getProgramWithProtocolText(protocolDts, /*includeTypeScriptServices*/ true);
+
+    const protocolFile = program.getSourceFile("protocol.d.ts");
+    const extraDeclarations = DeclarationsWalker.getExtraDeclarations(program.getTypeChecker(), protocolFile);
+    if (extraDeclarations) {
+        protocolDts += extraDeclarations;
+    }
+    // do sanity check and try to compile generated text as standalone program
+    const sanityCheckProgram = getProgramWithProtocolText(protocolDts, /*includeTypeScriptServices*/ false);
+    const diagnostics = [...program.getSyntacticDiagnostics(), ...program.getSemanticDiagnostics(), ...program.getGlobalDiagnostics()];
+    if (diagnostics.length) {
+        const flattenedDiagnostics = diagnostics.map(d => ts.flattenDiagnosticMessageText(d.messageText, "\n")).join("\n");
+        throw new Error(`Unexpected errors during sanity check: ${flattenedDiagnostics}`);
+    }
+    return protocolDts;
+}
+
+if (process.argv.length < 5) {
+    console.log(`Expected 3 arguments: path to 'protocol.ts', path to 'typescriptservices.d.ts' and path to output file`);
+    process.exit(1);
+}
+
+const protocolTs = process.argv[2];
+const typeScriptServicesDts = process.argv[3];
+const outputFile = process.argv[4];
+const generatedProtocolDts = generateProtocolFile(protocolTs, typeScriptServicesDts);
+ts.sys.writeFile(outputFile, generatedProtocolDts);

scripts/processDiagnosticMessages.ts

@@ -86,7 +86,7 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
         '/// <reference path="types.ts" />\r\n' +
         '/* @internal */\r\n' +
         'namespace ts {\r\n' +
-        '    export var Diagnostics = {\r\n';
+        '    export const Diagnostics = {\r\n';
     var names = Utilities.getObjectKeys(messageTable);
     for (var i = 0; i < names.length; i++) {
         var name = names[i];

scripts/tslint/preferConstRule.ts

@@ -9,44 +9,12 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function isBindingPattern(node: ts.Node): node is ts.BindingPattern {
-    return !!node && (node.kind === ts.SyntaxKind.ArrayBindingPattern || node.kind === ts.SyntaxKind.ObjectBindingPattern);
-}
-
-function walkUpBindingElementsAndPatterns(node: ts.Node): ts.Node {
-    while (node && (node.kind === ts.SyntaxKind.BindingElement || isBindingPattern(node))) {
-        node = node.parent;
-    }
-
-    return node;
-}
-
-function getCombinedNodeFlags(node: ts.Node): ts.NodeFlags {
-    node = walkUpBindingElementsAndPatterns(node);
-
-    let flags = node.flags;
-    if (node.kind === ts.SyntaxKind.VariableDeclaration) {
-        node = node.parent;
-    }
-
-    if (node && node.kind === ts.SyntaxKind.VariableDeclarationList) {
-        flags |= node.flags;
-        node = node.parent;
-    }
-
-    if (node && node.kind === ts.SyntaxKind.VariableStatement) {
-        flags |= node.flags;
-    }
-
-    return flags;
-}
-
 function isLet(node: ts.Node) {
-    return !!(getCombinedNodeFlags(node) & ts.NodeFlags.Let);
+    return !!(ts.getCombinedNodeFlags(node) & ts.NodeFlags.Let);
 }
 
 function isExported(node: ts.Node) {
-    return !!(getCombinedNodeFlags(node) & ts.NodeFlags.Export);
+    return !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
 }
 
 function isAssignmentOperator(token: ts.SyntaxKind): boolean {
@@ -125,11 +93,16 @@ class PreferConstWalker extends Lint.RuleWalker {
 
     private visitBindingPatternIdentifiers(pattern: ts.BindingPattern) {
         for (const element of pattern.elements) {
-            if (element.name.kind === ts.SyntaxKind.Identifier) {
-                this.markAssignment(element.name as ts.Identifier);
+            if (element.kind !== ts.SyntaxKind.BindingElement) {
+                continue;
+            }
+
+            const name = (<ts.BindingElement>element).name;
+            if (name.kind === ts.SyntaxKind.Identifier) {
+                this.markAssignment(name as ts.Identifier);
             }
             else {
-                this.visitBindingPatternIdentifiers(element.name as ts.BindingPattern);
+                this.visitBindingPatternIdentifiers(name as ts.BindingPattern);
             }
         }
     }
@@ -153,7 +126,7 @@ class PreferConstWalker extends Lint.RuleWalker {
     visitModuleDeclaration(node: ts.ModuleDeclaration) {
         if (node.body.kind === ts.SyntaxKind.ModuleBlock) {
             // For some reason module blocks are left out of the visit block traversal
-            this.visitBlock(node.body as ts.ModuleBlock);
+            this.visitBlock(node.body as any as ts.Block);
         }
         super.visitModuleDeclaration(node);
     }
@@ -223,7 +196,9 @@ class PreferConstWalker extends Lint.RuleWalker {
 
     private collectBindingPatternIdentifiers(value: ts.VariableDeclaration, pattern: ts.BindingPattern, table: ts.MapLike<DeclarationUsages>) {
         for (const element of pattern.elements) {
-            this.collectNameIdentifiers(value, element.name, table);
+            if (element.kind === ts.SyntaxKind.BindingElement) {
+                this.collectNameIdentifiers(value, (<ts.BindingElement>element).name, table);
+            }
         }
     }
 }

scripts/tslint/typeOperatorSpacingRule.ts

@@ -18,8 +18,13 @@ class TypeOperatorSpacingWalker extends Lint.RuleWalker {
             for (let i = 1; i < types.length; i++) {
                 const currentType = types[i];
                 if (expectedStart !== currentType.pos || currentType.getLeadingTriviaWidth() !== 1) {
-                    const failure = this.createFailure(currentType.pos, currentType.getWidth(), Rule.FAILURE_STRING);
-                    this.addFailure(failure);
+                    const sourceFile = currentType.getSourceFile();
+                    const previousTypeEndPos = sourceFile.getLineAndCharacterOfPosition(types[i - 1].end);
+                    const currentTypeStartPos = sourceFile.getLineAndCharacterOfPosition(currentType.pos);
+                    if (previousTypeEndPos.line === currentTypeStartPos.line) {
+                        const failure = this.createFailure(currentType.pos, currentType.getWidth(), Rule.FAILURE_STRING);
+                        this.addFailure(failure);
+                    }
                 }
                 expectedStart = currentType.end + 2;
             }

src/compiler/commandLineParser.ts

@@ -5,12 +5,15 @@
 /// <reference path="scanner.ts"/>
 
 namespace ts {
+    /* @internal */
+    export const compileOnSaveCommandLineOption: CommandLineOption = { name: "compileOnSave", type: "boolean" };
     /* @internal */
     export const optionDeclarations: CommandLineOption[] = [
         {
             name: "charset",
             type: "string",
         },
+        compileOnSaveCommandLineOption,
         {
             name: "declaration",
             shortName: "d",
@@ -30,6 +33,7 @@ namespace ts {
         {
             name: "extendedDiagnostics",
             type: "boolean",
+            experimental: true
         },
         {
             name: "emitBOM",
@@ -97,7 +101,7 @@ namespace ts {
                 "amd": ModuleKind.AMD,
                 "system": ModuleKind.System,
                 "umd": ModuleKind.UMD,
-                "es6": ModuleKind.ES6,
+                "es6": ModuleKind.ES2015,
                 "es2015": ModuleKind.ES2015,
             }),
             description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
@@ -257,8 +261,10 @@ namespace ts {
             type: createMap({
                 "es3": ScriptTarget.ES3,
                 "es5": ScriptTarget.ES5,
-                "es6": ScriptTarget.ES6,
+                "es6": ScriptTarget.ES2015,
                 "es2015": ScriptTarget.ES2015,
+                "es2016": ScriptTarget.ES2016,
+                "es2017": ScriptTarget.ES2017,
             }),
             description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015,
             paramType: Diagnostics.VERSION,
@@ -293,6 +299,7 @@ namespace ts {
                 "classic": ModuleResolutionKind.Classic,
             }),
             description: Diagnostics.Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
+            paramType: Diagnostics.STRATEGY,
         },
         {
             name: "allowUnusedLabels",
@@ -406,6 +413,7 @@ namespace ts {
                     "es2017": "lib.es2017.d.ts",
                     // Host only
                     "dom": "lib.dom.d.ts",
+                    "dom.iterable": "lib.dom.iterable.d.ts",
                     "webworker": "lib.webworker.d.ts",
                     "scripthost": "lib.scripthost.d.ts",
                     // ES2015 Or ESNext By-feature options
@@ -433,6 +441,16 @@ namespace ts {
             name: "strictNullChecks",
             type: "boolean",
             description: Diagnostics.Enable_strict_null_checks
+        },
+        {
+            name: "importHelpers",
+            type: "boolean",
+            description: Diagnostics.Import_emit_helpers_from_tslib
+        },
+        {
+            name: "alwaysStrict",
+            type: "boolean",
+            description: Diagnostics.Parse_in_strict_mode_and_emit_use_strict_for_each_source_file
         }
     ];
 
@@ -669,10 +687,10 @@ namespace ts {
       * @param fileName The path to the config file
       * @param jsonText The text of the config file
       */
-    export function parseConfigFileTextToJson(fileName: string, jsonText: string): { config?: any; error?: Diagnostic } {
+    export function parseConfigFileTextToJson(fileName: string, jsonText: string, stripComments = true): { config?: any; error?: Diagnostic } {
         try {
-            const jsonTextWithoutComments = removeComments(jsonText);
-            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
+            const jsonTextToParse = stripComments ? removeComments(jsonText) : jsonText;
+            return { config: /\S/.test(jsonTextToParse) ? JSON.parse(jsonTextToParse) : {} };
         }
         catch (e) {
             return { error: createCompilerDiagnostic(Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
@@ -799,15 +817,49 @@ namespace ts {
       * @param basePath A root directory to resolve relative path entries in the config
       *    file to. e.g. outDir
       */
-    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions: CompilerOptions = {}, configFileName?: string): ParsedCommandLine {
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions: CompilerOptions = {}, configFileName?: string, resolutionStack: Path[] = []): ParsedCommandLine {
         const errors: Diagnostic[] = [];
-        const compilerOptions: CompilerOptions = convertCompilerOptionsFromJsonWorker(json["compilerOptions"], basePath, errors, configFileName);
-        const options = extend(existingOptions, compilerOptions);
+        const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
+        const resolvedPath = toPath(configFileName || "", basePath, getCanonicalFileName);
+        if (resolutionStack.indexOf(resolvedPath) >= 0) {
+            return {
+                options: {},
+                fileNames: [],
+                typingOptions: {},
+                raw: json,
+                errors: [createCompilerDiagnostic(Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, [...resolutionStack, resolvedPath].join(" -> "))],
+                wildcardDirectories: {}
+            };
+        }
+
+        let options: CompilerOptions = convertCompilerOptionsFromJsonWorker(json["compilerOptions"], basePath, errors, configFileName);
         const typingOptions: TypingOptions = convertTypingOptionsFromJsonWorker(json["typingOptions"], basePath, errors, configFileName);
 
+        if (json["extends"]) {
+            let [include, exclude, files, baseOptions]: [string[], string[], string[], CompilerOptions] = [undefined, undefined, undefined, {}];
+            if (typeof json["extends"] === "string") {
+                [include, exclude, files, baseOptions] = (tryExtendsName(json["extends"]) || [include, exclude, files, baseOptions]);
+            }
+            else {
+                errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));
+            }
+            if (include && !json["include"]) {
+                json["include"] = include;
+            }
+            if (exclude && !json["exclude"]) {
+                json["exclude"] = exclude;
+            }
+            if (files && !json["files"]) {
+                json["files"] = files;
+            }
+            options = assign({}, baseOptions, options);
+        }
+
+        options = extend(existingOptions, options);
         options.configFilePath = configFileName;
 
         const { fileNames, wildcardDirectories } = getFileNames(errors);
+        const compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
 
         return {
             options,
@@ -815,9 +867,43 @@ namespace ts {
             typingOptions,
             raw: json,
             errors,
-            wildcardDirectories
+            wildcardDirectories,
+            compileOnSave
         };
 
+        function tryExtendsName(extendedConfig: string): [string[], string[], string[], CompilerOptions] {
+            // If the path isn't a rooted or relative path, don't try to resolve it (we reserve the right to special case module-id like paths in the future)
+            if (!(isRootedDiskPath(extendedConfig) || startsWith(normalizeSlashes(extendedConfig), "./") || startsWith(normalizeSlashes(extendedConfig), "../"))) {
+                errors.push(createCompilerDiagnostic(Diagnostics.The_path_in_an_extends_options_must_be_relative_or_rooted));
+                return;
+            }
+            let extendedConfigPath = toPath(extendedConfig, basePath, getCanonicalFileName);
+            if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, ".json")) {
+                extendedConfigPath = `${extendedConfigPath}.json` as Path;
+                if (!host.fileExists(extendedConfigPath)) {
+                    errors.push(createCompilerDiagnostic(Diagnostics.File_0_does_not_exist, extendedConfig));
+                    return;
+                }
+            }
+            const extendedResult = readConfigFile(extendedConfigPath, path => host.readFile(path));
+            if (extendedResult.error) {
+                errors.push(extendedResult.error);
+                return;
+            }
+            const extendedDirname = getDirectoryPath(extendedConfigPath);
+            const relativeDifference = convertToRelativePath(extendedDirname, basePath, getCanonicalFileName);
+            const updatePath: (path: string) => string = path => isRootedDiskPath(path) ? path : combinePaths(relativeDifference, path);
+            // Merge configs (copy the resolution stack so it is never reused between branches in potential diamond-problem scenarios)
+            const result = parseJsonConfigFileContent(extendedResult.config, host, extendedDirname, /*existingOptions*/undefined, getBaseFileName(extendedConfigPath), resolutionStack.concat([resolvedPath]));
+            errors.push(...result.errors);
+            const [include, exclude, files] = map(["include", "exclude", "files"], key => {
+                if (!json[key] && extendedResult.config[key]) {
+                    return map(extendedResult.config[key], updatePath);
+                }
+            });
+            return [include, exclude, files, result.options];
+        }
+
         function getFileNames(errors: Diagnostic[]): ExpandResult {
             let fileNames: string[];
             if (hasProperty(json, "files")) {
@@ -852,14 +938,13 @@ namespace ts {
                 errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
             }
             else {
-                // By default, exclude common package folders
+                // By default, exclude common package folders and the outDir
                 excludeSpecs = ["node_modules", "bower_components", "jspm_packages"];
-            }
 
-            // Always exclude the output directory unless explicitly included
-            const outDir = json["compilerOptions"] && json["compilerOptions"]["outDir"];
-            if (outDir) {
-                excludeSpecs.push(outDir);
+                const outDir = json["compilerOptions"] && json["compilerOptions"]["outDir"];
+                if (outDir) {
+                    excludeSpecs.push(outDir);
+                }
             }
 
             if (fileNames === undefined && includeSpecs === undefined) {
@@ -870,13 +955,24 @@ namespace ts {
         }
     }
 
+    export function convertCompileOnSaveOptionFromJson(jsonOption: any, basePath: string, errors: Diagnostic[]): boolean {
+        if (!hasProperty(jsonOption, compileOnSaveCommandLineOption.name)) {
+            return false;
+        }
+        const result = convertJsonOption(compileOnSaveCommandLineOption, jsonOption["compileOnSave"], basePath, errors);
+        if (typeof result === "boolean" && result) {
+            return result;
+        }
+        return false;
+    }
+
     export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: CompilerOptions, errors: Diagnostic[] } {
         const errors: Diagnostic[] = [];
         const options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
         return { options, errors };
     }
 
-    export function convertTypingOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: CompilerOptions, errors: Diagnostic[] } {
+    export function convertTypingOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: TypingOptions, errors: Diagnostic[] } {
         const errors: Diagnostic[] = [];
         const options = convertTypingOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
         return { options, errors };
@@ -885,7 +981,9 @@ namespace ts {
     function convertCompilerOptionsFromJsonWorker(jsonOptions: any,
         basePath: string, errors: Diagnostic[], configFileName?: string): CompilerOptions {
 
-        const options: CompilerOptions = getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true } : {};
+        const options: CompilerOptions = getBaseFileName(configFileName) === "jsconfig.json"
+            ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true }
+            : {};
         convertOptionsFromJson(optionDeclarations, jsonOptions, basePath, options, Diagnostics.Unknown_compiler_option_0, errors);
         return options;
     }

src/compiler/comments.ts

@@ -0,0 +1,347 @@
+/// <reference path="sourcemap.ts" />
+
+/* @internal */
+namespace ts {
+    export interface CommentWriter {
+        reset(): void;
+        setSourceFile(sourceFile: SourceFile): void;
+        emitNodeWithComments(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+        emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void): void;
+        emitTrailingCommentsOfPosition(pos: number): void;
+    }
+
+    export function createCommentWriter(host: EmitHost, writer: EmitTextWriter, sourceMap: SourceMapWriter): CommentWriter {
+        const compilerOptions = host.getCompilerOptions();
+        const extendedDiagnostics = compilerOptions.extendedDiagnostics;
+        const newLine = host.getNewLine();
+        const { emitPos } = sourceMap;
+
+        let containerPos = -1;
+        let containerEnd = -1;
+        let declarationListContainerEnd = -1;
+        let currentSourceFile: SourceFile;
+        let currentText: string;
+        let currentLineMap: number[];
+        let detachedCommentsInfo: { nodePos: number, detachedCommentEndPos: number}[];
+        let hasWrittenComment = false;
+        let disabled: boolean = compilerOptions.removeComments;
+
+        return {
+            reset,
+            setSourceFile,
+            emitNodeWithComments,
+            emitBodyWithDetachedComments,
+            emitTrailingCommentsOfPosition,
+        };
+
+        function emitNodeWithComments(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+            if (disabled) {
+                emitCallback(emitContext, node);
+                return;
+            }
+
+            if (node) {
+                const { pos, end } = getCommentRange(node);
+                const emitFlags = getEmitFlags(node);
+                if ((pos < 0 && end < 0) || (pos === end)) {
+                    // Both pos and end are synthesized, so just emit the node without comments.
+                    if (emitFlags & EmitFlags.NoNestedComments) {
+                        disabled = true;
+                        emitCallback(emitContext, node);
+                        disabled = false;
+                    }
+                    else {
+                        emitCallback(emitContext, node);
+                    }
+                }
+                else {
+                    if (extendedDiagnostics) {
+                        performance.mark("preEmitNodeWithComment");
+                    }
+
+                    const isEmittedNode = node.kind !== SyntaxKind.NotEmittedStatement;
+                    const skipLeadingComments = pos < 0 || (emitFlags & EmitFlags.NoLeadingComments) !== 0;
+                    const skipTrailingComments = end < 0 || (emitFlags & EmitFlags.NoTrailingComments) !== 0;
+
+                    // Emit leading comments if the position is not synthesized and the node
+                    // has not opted out from emitting leading comments.
+                    if (!skipLeadingComments) {
+                        emitLeadingComments(pos, isEmittedNode);
+                    }
+
+                    // Save current container state on the stack.
+                    const savedContainerPos = containerPos;
+                    const savedContainerEnd = containerEnd;
+                    const savedDeclarationListContainerEnd = declarationListContainerEnd;
+
+                    if (!skipLeadingComments) {
+                        containerPos = pos;
+                    }
+
+                    if (!skipTrailingComments) {
+                        containerEnd = end;
+
+                        // To avoid invalid comment emit in a down-level binding pattern, we
+                        // keep track of the last declaration list container's end
+                        if (node.kind === SyntaxKind.VariableDeclarationList) {
+                            declarationListContainerEnd = end;
+                        }
+                    }
+
+                    if (extendedDiagnostics) {
+                        performance.measure("commentTime", "preEmitNodeWithComment");
+                    }
+
+                    if (emitFlags & EmitFlags.NoNestedComments) {
+                        disabled = true;
+                        emitCallback(emitContext, node);
+                        disabled = false;
+                    }
+                    else {
+                        emitCallback(emitContext, node);
+                    }
+
+                    if (extendedDiagnostics) {
+                        performance.mark("beginEmitNodeWithComment");
+                    }
+
+                    // Restore previous container state.
+                    containerPos = savedContainerPos;
+                    containerEnd = savedContainerEnd;
+                    declarationListContainerEnd = savedDeclarationListContainerEnd;
+
+                    // Emit trailing comments if the position is not synthesized and the node
+                    // has not opted out from emitting leading comments and is an emitted node.
+                    if (!skipTrailingComments && isEmittedNode) {
+                        emitTrailingComments(end);
+                    }
+
+                    if (extendedDiagnostics) {
+                        performance.measure("commentTime", "beginEmitNodeWithComment");
+                    }
+                }
+            }
+        }
+
+        function emitBodyWithDetachedComments(node: Node, detachedRange: TextRange, emitCallback: (node: Node) => void) {
+            if (extendedDiagnostics) {
+                performance.mark("preEmitBodyWithDetachedComments");
+            }
+
+            const { pos, end } = detachedRange;
+            const emitFlags = getEmitFlags(node);
+            const skipLeadingComments = pos < 0 || (emitFlags & EmitFlags.NoLeadingComments) !== 0;
+            const skipTrailingComments = disabled || end < 0 || (emitFlags & EmitFlags.NoTrailingComments) !== 0;
+
+            if (!skipLeadingComments) {
+                emitDetachedCommentsAndUpdateCommentsInfo(detachedRange);
+            }
+
+            if (extendedDiagnostics) {
+                performance.measure("commentTime", "preEmitBodyWithDetachedComments");
+            }
+
+            if (emitFlags & EmitFlags.NoNestedComments && !disabled) {
+                disabled = true;
+                emitCallback(node);
+                disabled = false;
+            }
+            else {
+                emitCallback(node);
+            }
+
+            if (extendedDiagnostics) {
+                performance.mark("beginEmitBodyWithDetachedCommetns");
+            }
+
+            if (!skipTrailingComments) {
+                emitLeadingComments(detachedRange.end, /*isEmittedNode*/ true);
+            }
+
+            if (extendedDiagnostics) {
+                performance.measure("commentTime", "beginEmitBodyWithDetachedCommetns");
+            }
+        }
+
+        function emitLeadingComments(pos: number, isEmittedNode: boolean) {
+            hasWrittenComment = false;
+
+            if (isEmittedNode) {
+                forEachLeadingCommentToEmit(pos, emitLeadingComment);
+            }
+            else if (pos === 0) {
+                // If the node will not be emitted in JS, remove all the comments(normal, pinned and ///) associated with the node,
+                // unless it is a triple slash comment at the top of the file.
+                // For Example:
+                //      /// <reference-path ...>
+                //      declare var x;
+                //      /// <reference-path ...>
+                //      interface F {}
+                //  The first /// will NOT be removed while the second one will be removed even though both node will not be emitted
+                forEachLeadingCommentToEmit(pos, emitTripleSlashLeadingComment);
+            }
+        }
+
+        function emitTripleSlashLeadingComment(commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean, rangePos: number) {
+            if (isTripleSlashComment(commentPos, commentEnd)) {
+                emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos);
+            }
+        }
+
+        function emitLeadingComment(commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean, rangePos: number) {
+            if (!hasWrittenComment) {
+                emitNewLineBeforeLeadingCommentOfPosition(currentLineMap, writer, rangePos, commentPos);
+                hasWrittenComment = true;
+            }
+
+            // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
+            emitPos(commentPos);
+            writeCommentRange(currentText, currentLineMap, writer, commentPos, commentEnd, newLine);
+            emitPos(commentEnd);
+
+            if (hasTrailingNewLine) {
+                writer.writeLine();
+            }
+            else {
+                writer.write(" ");
+            }
+        }
+
+        function emitTrailingComments(pos: number) {
+            forEachTrailingCommentToEmit(pos, emitTrailingComment);
+        }
+
+        function emitTrailingComment(commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean) {
+            // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment2*/
+            if (!writer.isAtStartOfLine()) {
+                writer.write(" ");
+            }
+
+            emitPos(commentPos);
+            writeCommentRange(currentText, currentLineMap, writer, commentPos, commentEnd, newLine);
+            emitPos(commentEnd);
+
+            if (hasTrailingNewLine) {
+                writer.writeLine();
+            }
+        }
+
+        function emitTrailingCommentsOfPosition(pos: number) {
+            if (disabled) {
+                return;
+            }
+
+            if (extendedDiagnostics) {
+                performance.mark("beforeEmitTrailingCommentsOfPosition");
+            }
+
+            forEachTrailingCommentToEmit(pos, emitTrailingCommentOfPosition);
+
+            if (extendedDiagnostics) {
+                performance.measure("commentTime", "beforeEmitTrailingCommentsOfPosition");
+            }
+        }
+
+        function emitTrailingCommentOfPosition(commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean) {
+            // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space
+
+            emitPos(commentPos);
+            writeCommentRange(currentText, currentLineMap, writer, commentPos, commentEnd, newLine);
+            emitPos(commentEnd);
+
+            if (hasTrailingNewLine) {
+                writer.writeLine();
+            }
+            else {
+                writer.write(" ");
+            }
+        }
+
+        function forEachLeadingCommentToEmit(pos: number, cb: (commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean, rangePos: number) => void) {
+            // Emit the leading comments only if the container's pos doesn't match because the container should take care of emitting these comments
+            if (containerPos === -1 || pos !== containerPos) {
+                if (hasDetachedComments(pos)) {
+                    forEachLeadingCommentWithoutDetachedComments(cb);
+                }
+                else {
+                    forEachLeadingCommentRange(currentText, pos, cb, /*state*/ pos);
+                }
+            }
+        }
+
+        function forEachTrailingCommentToEmit(end: number, cb: (commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean) => void) {
+            // Emit the trailing comments only if the container's end doesn't match because the container should take care of emitting these comments
+            if (containerEnd === -1 || (end !== containerEnd && end !== declarationListContainerEnd)) {
+                forEachTrailingCommentRange(currentText, end, cb);
+            }
+        }
+
+        function reset() {
+            currentSourceFile = undefined;
+            currentText = undefined;
+            currentLineMap = undefined;
+            detachedCommentsInfo = undefined;
+        }
+
+        function setSourceFile(sourceFile: SourceFile) {
+            currentSourceFile = sourceFile;
+            currentText = currentSourceFile.text;
+            currentLineMap = getLineStarts(currentSourceFile);
+            detachedCommentsInfo = undefined;
+        }
+
+        function hasDetachedComments(pos: number) {
+            return detachedCommentsInfo !== undefined && lastOrUndefined(detachedCommentsInfo).nodePos === pos;
+        }
+
+        function forEachLeadingCommentWithoutDetachedComments(cb: (commentPos: number, commentEnd: number, kind: SyntaxKind, hasTrailingNewLine: boolean, rangePos: number) => void) {
+            // get the leading comments from detachedPos
+            const pos = lastOrUndefined(detachedCommentsInfo).detachedCommentEndPos;
+            if (detachedCommentsInfo.length - 1) {
+                detachedCommentsInfo.pop();
+            }
+            else {
+                detachedCommentsInfo = undefined;
+            }
+
+            forEachLeadingCommentRange(currentText, pos, cb, /*state*/ pos);
+        }
+
+        function emitDetachedCommentsAndUpdateCommentsInfo(range: TextRange) {
+            const currentDetachedCommentInfo = emitDetachedComments(currentText, currentLineMap, writer, writeComment, range, newLine, disabled);
+            if (currentDetachedCommentInfo) {
+                if (detachedCommentsInfo) {
+                    detachedCommentsInfo.push(currentDetachedCommentInfo);
+                }
+                else {
+                    detachedCommentsInfo = [currentDetachedCommentInfo];
+                }
+            }
+        }
+
+        function writeComment(text: string, lineMap: number[], writer: EmitTextWriter, commentPos: number, commentEnd: number, newLine: string) {
+            emitPos(commentPos);
+            writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine);
+            emitPos(commentEnd);
+        }
+
+        /**
+         * Determine if the given comment is a triple-slash
+         *
+         * @return true if the comment is a triple-slash comment else false
+         **/
+        function isTripleSlashComment(commentPos: number, commentEnd: number) {
+            // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text
+            // so that we don't end up computing comment string and doing match for all // comments
+            if (currentText.charCodeAt(commentPos + 1) === CharacterCodes.slash &&
+                commentPos + 2 < commentEnd &&
+                currentText.charCodeAt(commentPos + 2) === CharacterCodes.slash) {
+                const textSubStr = currentText.substring(commentPos, commentEnd);
+                return textSubStr.match(fullTripleSlashReferencePathRegEx) ||
+                    textSubStr.match(fullTripleSlashAMDReferencePathRegEx) ?
+                    true : false;
+            }
+            return false;
+        }
+    }
+}

src/compiler/core.ts

@@ -1,7 +1,6 @@
-/// <reference path="types.ts"/>
+/// <reference path="types.ts"/>
 /// <reference path="performance.ts" />
 
-
 /* @internal */
 namespace ts {
     /**
@@ -21,6 +20,9 @@ namespace ts {
 
     const createObject = Object.create;
 
+    // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
+    export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
+
     export function createMap<T>(template?: MapLike<T>): Map<T> {
         const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword
 
@@ -47,6 +49,7 @@ namespace ts {
             contains,
             remove,
             forEachValue: forEachValueInMap,
+            getKeys,
             clear,
         };
 
@@ -56,6 +59,14 @@ namespace ts {
             }
         }
 
+        function getKeys() {
+            const keys: Path[] = [];
+            for (const key in files) {
+                keys.push(<Path>key);
+            }
+            return keys;
+        }
+
         // path should already be well-formed so it does not need to be normalized
         function get(path: Path): T {
             return files[toKey(path)];
@@ -113,6 +124,23 @@ namespace ts {
         return undefined;
     }
 
+    /**
+     * Iterates through `array` by index and performs the callback on each element of array until the callback
+     * returns a falsey value, then returns false.
+     * If no such value is found, the callback is applied to each element of array and `true` is returned.
+     */
+    export function every<T>(array: T[], callback: (element: T, index: number) => boolean): boolean {
+        if (array) {
+            for (let i = 0, len = array.length; i < len; i++) {
+                if (!callback(array[i], i)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
     /** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */
     export function find<T>(array: T[], predicate: (element: T, index: number) => boolean): T | undefined {
         for (let i = 0, len = array.length; i < len; i++) {
@@ -169,11 +197,12 @@ namespace ts {
         return -1;
     }
 
-    export function countWhere<T>(array: T[], predicate: (x: T) => boolean): number {
+    export function countWhere<T>(array: T[], predicate: (x: T, i: number) => boolean): number {
         let count = 0;
         if (array) {
-            for (const v of array) {
-                if (predicate(v)) {
+            for (let i = 0; i < array.length; i++) {
+                const v = array[i];
+                if (predicate(v, i)) {
                     count++;
                 }
             }
@@ -185,6 +214,8 @@ namespace ts {
      * Filters an array by a predicate function. Returns the same array instance if the predicate is
      * true for all elements, otherwise returns a new array instance containing the filtered subset.
      */
+    export function filter<T, U extends T>(array: T[], f: (x: T) => x is U): U[];
+    export function filter<T>(array: T[], f: (x: T) => boolean): T[];
     export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
         if (array) {
             const len = array.length;
@@ -232,24 +263,183 @@ namespace ts {
         array.length = outIndex;
     }
 
-    export function map<T, U>(array: T[], f: (x: T) => U): U[] {
+    export function map<T, U>(array: T[], f: (x: T, i: number) => U): U[] {
         let result: U[];
         if (array) {
             result = [];
-            for (const v of array) {
-                result.push(f(v));
+            for (let i = 0; i < array.length; i++) {
+                result.push(f(array[i], i));
             }
         }
         return result;
     }
 
+    // Maps from T to T and avoids allocation if all elements map to themselves
+    export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[] {
+        let result: T[];
+        if (array) {
+            for (let i = 0; i < array.length; i++) {
+                if (result) {
+                    result.push(f(array[i], i));
+                }
+                else {
+                    const item = array[i];
+                    const mapped = f(item, i);
+                    if (item !== mapped) {
+                        result = array.slice(0, i);
+                        result.push(mapped);
+                    }
+                }
+            }
+        }
+        return result || array;
+    }
+
+    /**
+     * Flattens an array containing a mix of array or non-array elements.
+     *
+     * @param array The array to flatten.
+     */
+    export function flatten<T>(array: (T | T[])[]): T[] {
+        let result: T[];
+        if (array) {
+            result = [];
+            for (const v of array) {
+                if (v) {
+                    if (isArray(v)) {
+                        addRange(result, v);
+                    }
+                    else {
+                        result.push(v);
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Maps an array. If the mapped value is an array, it is spread into the result.
+     *
+     * @param array The array to map.
+     * @param mapfn The callback used to map the result into one or more values.
+     */
+    export function flatMap<T, U>(array: T[], mapfn: (x: T, i: number) => U | U[]): U[] {
+        let result: U[];
+        if (array) {
+            result = [];
+            for (let i = 0; i < array.length; i++) {
+                const v = mapfn(array[i], i);
+                if (v) {
+                    if (isArray(v)) {
+                        addRange(result, v);
+                    }
+                    else {
+                        result.push(v);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Computes the first matching span of elements and returns a tuple of the first span
+     * and the remaining elements.
+     */
+    export function span<T>(array: T[], f: (x: T, i: number) => boolean): [T[], T[]] {
+        if (array) {
+            for (let i = 0; i < array.length; i++) {
+                if (!f(array[i], i)) {
+                    return [array.slice(0, i), array.slice(i)];
+                }
+            }
+            return [array.slice(0), []];
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Maps contiguous spans of values with the same key.
+     *
+     * @param array The array to map.
+     * @param keyfn A callback used to select the key for an element.
+     * @param mapfn A callback used to map a contiguous chunk of values to a single value.
+     */
+    export function spanMap<T, K, U>(array: T[], keyfn: (x: T, i: number) => K, mapfn: (chunk: T[], key: K, start: number, end: number) => U): U[] {
+        let result: U[];
+        if (array) {
+            result = [];
+            const len = array.length;
+            let previousKey: K;
+            let key: K;
+            let start = 0;
+            let pos = 0;
+            while (start < len) {
+                while (pos < len) {
+                    const value = array[pos];
+                    key = keyfn(value, pos);
+                    if (pos === 0) {
+                        previousKey = key;
+                    }
+                    else if (key !== previousKey) {
+                        break;
+                    }
+
+                    pos++;
+                }
+
+                if (start < pos) {
+                    const v = mapfn(array.slice(start, pos), previousKey, start, pos);
+                    if (v) {
+                        result.push(v);
+                    }
+
+                    start = pos;
+                }
+
+                previousKey = key;
+                pos++;
+            }
+        }
+
+        return result;
+    }
+
+    export function mapObject<T, U>(object: MapLike<T>, f: (key: string, x: T) => [string, U]): MapLike<U> {
+        let result: MapLike<U>;
+        if (object) {
+            result = {};
+            for (const v of getOwnKeys(object)) {
+                const [key, value]: [string, U] = f(v, object[v]) || [undefined, undefined];
+                if (key !== undefined) {
+                    result[key] = value;
+                }
+            }
+        }
+        return result;
+    }
+
+    export function some<T>(array: T[], predicate?: (value: T) => boolean): boolean {
+        if (array) {
+            for (const v of array) {
+                if (!predicate || predicate(v)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     export function concatenate<T>(array1: T[], array2: T[]): T[] {
         if (!array2 || !array2.length) return array1;
         if (!array1 || !array1.length) return array2;
-
-        return array1.concat(array2);
+        return [...array1, ...array2];
     }
 
+    // TODO: fixme (N^2) - add optional comparer so collection can be sorted before deduplication.
     export function deduplicate<T>(array: T[], areEqual?: (a: T, b: T) => boolean): T[] {
         let result: T[];
         if (array) {
@@ -266,6 +456,27 @@ namespace ts {
         return result;
     }
 
+    /**
+     * Compacts an array, removing any falsey elements.
+     */
+    export function compact<T>(array: T[]): T[] {
+        let result: T[];
+        if (array) {
+            for (let i = 0; i < array.length; i++) {
+                const v = array[i];
+                if (result || !v) {
+                    if (!result) {
+                        result = array.slice(0, i);
+                    }
+                    if (v) {
+                        result.push(v);
+                    }
+                }
+            }
+        }
+        return result || array;
+    }
+
     export function sum(array: any[], prop: string): number {
         let result = 0;
         for (const v of array) {
@@ -277,7 +488,9 @@ namespace ts {
     export function addRange<T>(to: T[], from: T[]): void {
         if (to && from) {
             for (const v of from) {
-                to.push(v);
+                if (v !== undefined) {
+                    to.push(v);
+                }
             }
         }
     }
@@ -292,15 +505,31 @@ namespace ts {
         return true;
     }
 
+    export function firstOrUndefined<T>(array: T[]): T {
+        return array && array.length > 0
+            ? array[0]
+            : undefined;
+    }
+
+    export function singleOrUndefined<T>(array: T[]): T {
+        return array && array.length === 1
+            ? array[0]
+            : undefined;
+    }
+
+    export function singleOrMany<T>(array: T[]): T | T[] {
+        return array && array.length === 1
+            ? array[0]
+            : array;
+    }
+
     /**
      * Returns the last element of an array if non-empty, undefined otherwise.
      */
     export function lastOrUndefined<T>(array: T[]): T {
-        if (array.length === 0) {
-            return undefined;
-        }
-
-        return array[array.length - 1];
+        return array && array.length > 0
+            ? array[array.length - 1]
+            : undefined;
     }
 
     /**
@@ -310,18 +539,25 @@ namespace ts {
      * @param array A sorted array whose first element must be no larger than number
      * @param number The value to be searched for in the array.
      */
-    export function binarySearch(array: number[], value: number): number {
+    export function binarySearch<T>(array: T[], value: T, comparer?: (v1: T, v2: T) => number): number {
+        if (!array || array.length === 0) {
+            return -1;
+        }
+
         let low = 0;
         let high = array.length - 1;
+        comparer = comparer !== undefined
+            ? comparer
+            : (v1, v2) => (v1 < v2 ? -1 : (v1 > v2 ? 1 : 0));
 
         while (low <= high) {
             const middle = low + ((high - low) >> 1);
             const midValue = array[middle];
 
-            if (midValue === value) {
+            if (comparer(midValue, value) === 0) {
                 return middle;
             }
-            else if (midValue > value) {
+            else if (comparer(midValue, value) > 0) {
                 high = middle - 1;
             }
             else {
@@ -332,14 +568,15 @@ namespace ts {
         return ~low;
     }
 
-    export function reduceLeft<T>(array: T[], f: (a: T, x: T) => T): T;
-    export function reduceLeft<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
-    export function reduceLeft<T, U>(array: T[], f: (a: U, x: T) => U, initial?: U): U {
-        if (array) {
-            const count = array.length;
-            if (count > 0) {
-                let pos = 0;
-                let result: T | U;
+    export function reduceLeft<T, U>(array: T[], f: (memo: U, value: T, i: number) => U, initial: U, start?: number, count?: number): U;
+    export function reduceLeft<T>(array: T[], f: (memo: T, value: T, i: number) => T): T;
+    export function reduceLeft<T>(array: T[], f: (memo: T, value: T, i: number) => T, initial?: T, start?: number, count?: number): T {
+        if (array && array.length > 0) {
+            const size = array.length;
+            if (size > 0) {
+                let pos = start === undefined || start < 0 ? 0 : start;
+                const end = count === undefined || pos + count > size - 1 ? size - 1 : pos + count;
+                let result: T;
                 if (arguments.length <= 2) {
                     result = array[pos];
                     pos++;
@@ -347,23 +584,25 @@ namespace ts {
                 else {
                     result = initial;
                 }
-                while (pos < count) {
-                    result = f(<U>result, array[pos]);
+                while (pos <= end) {
+                    result = f(result, array[pos], pos);
                     pos++;
                 }
-                return <U>result;
+                return result;
             }
         }
         return initial;
     }
 
-    export function reduceRight<T>(array: T[], f: (a: T, x: T) => T): T;
-    export function reduceRight<T, U>(array: T[], f: (a: U, x: T) => U, initial: U): U;
-    export function reduceRight<T, U>(array: T[], f: (a: U, x: T) => U, initial?: U): U {
+    export function reduceRight<T, U>(array: T[], f: (memo: U, value: T, i: number) => U, initial: U, start?: number, count?: number): U;
+    export function reduceRight<T>(array: T[], f: (memo: T, value: T, i: number) => T): T;
+    export function reduceRight<T>(array: T[], f: (memo: T, value: T, i: number) => T, initial?: T, start?: number, count?: number): T {
         if (array) {
-            let pos = array.length - 1;
-            if (pos >= 0) {
-                let result: T | U;
+            const size = array.length;
+            if (size > 0) {
+                let pos = start === undefined || start > size - 1 ? size - 1 : start;
+                const end = count === undefined || pos - count < 0 ? 0 : pos - count;
+                let result: T;
                 if (arguments.length <= 2) {
                     result = array[pos];
                     pos--;
@@ -371,11 +610,11 @@ namespace ts {
                 else {
                     result = initial;
                 }
-                while (pos >= 0) {
-                    result = f(<U>result, array[pos]);
+                while (pos >= end) {
+                    result = f(result, array[pos], pos);
                     pos--;
                 }
-                return <U>result;
+                return result;
             }
         }
         return initial;
@@ -464,6 +703,18 @@ namespace ts {
         }
     }
 
+    export function assign<T1 extends MapLike<{}>, T2, T3>(t: T1, arg1: T2, arg2: T3): T1 & T2 & T3;
+    export function assign<T1 extends MapLike<{}>, T2>(t: T1, arg1: T2): T1 & T2;
+    export function assign<T1 extends MapLike<{}>>(t: T1, ...args: any[]): any;
+    export function assign<T1 extends MapLike<{}>>(t: T1, ...args: any[]) {
+        for (const arg of args) {
+            for (const p of getOwnKeys(arg)) {
+                t[p] = arg[p];
+            }
+        }
+        return t;
+    }
+
     /**
      * Reduce the properties of a map.
      *
@@ -539,6 +790,15 @@ namespace ts {
         return result;
     }
 
+    export function isEmpty<T>(map: Map<T>) {
+        for (const id in map) {
+            if (hasProperty(map, id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     export function cloneMap<T>(map: Map<T>) {
         const clone = createMap<T>();
         copyProperties(map, clone);
@@ -566,6 +826,36 @@ namespace ts {
         return result;
     }
 
+    /**
+     * Adds the value to an array of values associated with the key, and returns the array.
+     * Creates the array if it does not already exist.
+     */
+    export function multiMapAdd<V>(map: Map<V[]>, key: string, value: V): V[] {
+        const values = map[key];
+        if (values) {
+            values.push(value);
+            return values;
+        }
+        else {
+            return map[key] = [value];
+        }
+    }
+
+    /**
+     * Removes a value from an array of values associated with the key.
+     * Does not preserve the order of those values.
+     * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
+     */
+    export function multiMapRemove<V>(map: Map<V[]>, key: string, value: V): void {
+        const values = map[key];
+        if (values) {
+            unorderedRemoveItem(values, value);
+            if (!values.length) {
+                delete map[key];
+            }
+        }
+    }
+
     /**
      * Tests whether a value is an array.
      */
@@ -584,6 +874,72 @@ namespace ts {
         };
     }
 
+    /**
+     * High-order function, creates a function that executes a function composition.
+     * For example, `chain(a, b)` is the equivalent of `x => ((a', b') => y => b'(a'(y)))(a(x), b(x))`
+     *
+     * @param args The functions to chain.
+     */
+    export function chain<T, U>(...args: ((t: T) => (u: U) => U)[]): (t: T) => (u: U) => U;
+    export function chain<T, U>(a: (t: T) => (u: U) => U, b: (t: T) => (u: U) => U, c: (t: T) => (u: U) => U, d: (t: T) => (u: U) => U, e: (t: T) => (u: U) => U): (t: T) => (u: U) => U {
+        if (e) {
+            const args: ((t: T) => (u: U) => U)[] = [];
+            for (let i = 0; i < arguments.length; i++) {
+                args[i] = arguments[i];
+            }
+
+            return t => compose(...map(args, f => f(t)));
+        }
+        else if (d) {
+            return t => compose(a(t), b(t), c(t), d(t));
+        }
+        else if (c) {
+            return t => compose(a(t), b(t), c(t));
+        }
+        else if (b) {
+            return t => compose(a(t), b(t));
+        }
+        else if (a) {
+            return t => compose(a(t));
+        }
+        else {
+            return t => u => u;
+        }
+    }
+
+    /**
+     * High-order function, composes functions. Note that functions are composed inside-out;
+     * for example, `compose(a, b)` is the equivalent of `x => b(a(x))`.
+     *
+     * @param args The functions to compose.
+     */
+    export function compose<T>(...args: ((t: T) => T)[]): (t: T) => T;
+    export function compose<T>(a: (t: T) => T, b: (t: T) => T, c: (t: T) => T, d: (t: T) => T, e: (t: T) => T): (t: T) => T {
+        if (e) {
+            const args: ((t: T) => T)[] = [];
+            for (let i = 0; i < arguments.length; i++) {
+                args[i] = arguments[i];
+            }
+
+            return t => reduceLeft<(t: T) => T, T>(args, (u, f) => f(u), t);
+        }
+        else if (d) {
+            return t => d(c(b(a(t))));
+        }
+        else if (c) {
+            return t => c(b(a(t)));
+        }
+        else if (b) {
+            return t => b(a(t));
+        }
+        else if (a) {
+            return t => a(t);
+        }
+        else {
+            return t => t;
+        }
+    }
+
     function formatStringFromArgs(text: string, args: { [index: number]: any; }, baseIndex?: number): string {
         baseIndex = baseIndex || 0;
 
@@ -694,7 +1050,8 @@ namespace ts {
         if (a === undefined) return Comparison.LessThan;
         if (b === undefined) return Comparison.GreaterThan;
         if (ignoreCase) {
-            if (String.prototype.localeCompare) {
+            if (collator && String.prototype.localeCompare) {
+                // accent means a ≠ b, a ≠ á, a = A
                 const result = a.localeCompare(b, /*locales*/ undefined, { usage: "sort", sensitivity: "accent" });
                 return result < 0 ? Comparison.LessThan : result > 0 ? Comparison.GreaterThan : Comparison.EqualTo;
             }
@@ -775,7 +1132,9 @@ namespace ts {
         return path.replace(/\\/g, "/");
     }
 
-    // Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files")
+    /**
+     * Returns length of path root (i.e. length of "/", "x:/", "//server/share/, file:///user/files")
+    */
     export function getRootLength(path: string): number {
         if (path.charCodeAt(0) === CharacterCodes.slash) {
             if (path.charCodeAt(1) !== CharacterCodes.slash) return 1;
@@ -804,8 +1163,14 @@ namespace ts {
         return 0;
     }
 
-    export let directorySeparator = "/";
-    function getNormalizedParts(normalizedSlashedPath: string, rootLength: number) {
+    /**
+     * Internally, we represent paths as strings with '/' as the directory separator.
+     * When we make system calls (eg: LanguageServiceHost.getDirectory()),
+     * we expect the host to correctly handle paths in our specified format.
+     */
+    export const directorySeparator = "/";
+    const directorySeparatorCharCode = CharacterCodes.slash;
+    function getNormalizedParts(normalizedSlashedPath: string, rootLength: number): string[] {
         const parts = normalizedSlashedPath.substr(rootLength).split(directorySeparator);
         const normalized: string[] = [];
         for (const part of parts) {
@@ -829,10 +1194,27 @@ namespace ts {
     export function normalizePath(path: string): string {
         path = normalizeSlashes(path);
         const rootLength = getRootLength(path);
+        const root = path.substr(0, rootLength);
         const normalized = getNormalizedParts(path, rootLength);
-        return path.substr(0, rootLength) + normalized.join(directorySeparator);
+        if (normalized.length) {
+            const joinedParts = root + normalized.join(directorySeparator);
+            return pathEndsWithDirectorySeparator(path) ? joinedParts + directorySeparator : joinedParts;
+        }
+        else {
+            return root;
+        }
     }
 
+    /** A path ending with '/' refers to a directory only, never a file. */
+    export function pathEndsWithDirectorySeparator(path: string): boolean {
+        return path.charCodeAt(path.length - 1) === directorySeparatorCharCode;
+    }
+
+    /**
+     * Returns the path except for its basename. Eg:
+     *
+     * /path/to/file.ext -> /path/to
+     */
     export function getDirectoryPath(path: Path): Path;
     export function getDirectoryPath(path: string): string;
     export function getDirectoryPath(path: string): any {
@@ -843,10 +1225,49 @@ namespace ts {
         return path && !isRootedDiskPath(path) && path.indexOf("://") !== -1;
     }
 
+    export function isExternalModuleNameRelative(moduleName: string): boolean {
+        // TypeScript 1.0 spec (April 2014): 11.2.1
+        // An external module name is "relative" if the first term is "." or "..".
+        return /^\.\.?($|[\\/])/.test(moduleName);
+    }
+
+    export function getEmitScriptTarget(compilerOptions: CompilerOptions) {
+        return compilerOptions.target || ScriptTarget.ES3;
+    }
+
+    export function getEmitModuleKind(compilerOptions: CompilerOptions) {
+        return typeof compilerOptions.module === "number" ?
+            compilerOptions.module :
+            getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2015 ? ModuleKind.ES2015 : ModuleKind.CommonJS;
+    }
+
+    /* @internal */
+    export function hasZeroOrOneAsteriskCharacter(str: string): boolean {
+        let seenAsterisk = false;
+        for (let i = 0; i < str.length; i++) {
+            if (str.charCodeAt(i) === CharacterCodes.asterisk) {
+                if (!seenAsterisk) {
+                    seenAsterisk = true;
+                }
+                else {
+                    // have already seen asterisk
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
     export function isRootedDiskPath(path: string) {
         return getRootLength(path) !== 0;
     }
 
+    export function convertToRelativePath(absoluteOrRelativePath: string, basePath: string, getCanonicalFileName: (path: string) => string): string {
+        return !isRootedDiskPath(absoluteOrRelativePath)
+            ? absoluteOrRelativePath
+            : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
+    }
+
     function normalizedPathComponents(path: string, rootLength: number) {
         const normalizedParts = getNormalizedParts(path, rootLength);
         return [path.substr(0, rootLength)].concat(normalizedParts);
@@ -1338,6 +1759,14 @@ namespace ts {
         return options && options.allowJs ? allSupportedExtensions : supportedTypeScriptExtensions;
     }
 
+    export function hasJavaScriptFileExtension(fileName: string) {
+        return forEach(supportedJavascriptExtensions, extension => fileExtensionIs(fileName, extension));
+    }
+
+    export function hasTypeScriptFileExtension(fileName: string) {
+        return forEach(supportedTypeScriptExtensions, extension => fileExtensionIs(fileName, extension));
+    }
+
     export function isSupportedSourceFileName(fileName: string, compilerOptions?: CompilerOptions) {
         if (!fileName) { return false; }
 
@@ -1431,9 +1860,9 @@ namespace ts {
 
     export interface ObjectAllocator {
         getNodeConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Node;
-        getTokenConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Token;
-        getIdentifierConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Token;
-        getSourceFileConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => SourceFile;
+        getTokenConstructor(): new <TKind extends SyntaxKind>(kind: TKind, pos?: number, end?: number) => Token<TKind>;
+        getIdentifierConstructor(): new (kind: SyntaxKind.Identifier, pos?: number, end?: number) => Identifier;
+        getSourceFileConstructor(): new (kind: SyntaxKind.SourceFile, pos?: number, end?: number) => SourceFile;
         getSymbolConstructor(): new (flags: SymbolFlags, name: string) => Symbol;
         getTypeConstructor(): new (checker: TypeChecker, flags: TypeFlags) => Type;
         getSignatureConstructor(): new (checker: TypeChecker) => Signature;
@@ -1453,11 +1882,15 @@ namespace ts {
     }
 
     function Node(this: Node, kind: SyntaxKind, pos: number, end: number) {
+        this.id = 0;
         this.kind = kind;
         this.pos = pos;
         this.end = end;
         this.flags = NodeFlags.None;
+        this.modifierFlagsCache = ModifierFlags.None;
+        this.transformFlags = TransformFlags.None;
         this.parent = undefined;
+        this.original = undefined;
     }
 
     export let objectAllocator: ObjectAllocator = {
@@ -1478,7 +1911,10 @@ namespace ts {
     }
 
     export namespace Debug {
-        const currentAssertionLevel = AssertionLevel.None;
+        declare var process: any;
+        declare var require: any;
+
+        export let currentAssertionLevel = AssertionLevel.None;
 
         export function shouldAssert(level: AssertionLevel): boolean {
             return currentAssertionLevel >= level;
@@ -1500,20 +1936,117 @@ namespace ts {
         }
     }
 
-    export function copyListRemovingItem<T>(item: T, list: T[]) {
-        const copiedList: T[] = [];
-        for (const e of list) {
-            if (e !== item) {
-                copiedList.push(e);
-            }
+    /** Remove an item from an array, moving everything to its right one space left. */
+    export function orderedRemoveItemAt<T>(array: T[], index: number): void {
+        // This seems to be faster than either `array.splice(i, 1)` or `array.copyWithin(i, i+ 1)`.
+        for (let i = index; i < array.length - 1; i++) {
+            array[i] = array[i + 1];
         }
-        return copiedList;
+        array.pop();
     }
 
-    export function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string {
-        return useCaseSensitivefileNames
+    export function unorderedRemoveItemAt<T>(array: T[], index: number): void {
+        // Fill in the "hole" left at `index`.
+        array[index] = array[array.length - 1];
+        array.pop();
+    }
+
+    /** Remove the *first* occurrence of `item` from the array. */
+    export function unorderedRemoveItem<T>(array: T[], item: T): void {
+        unorderedRemoveFirstItemWhere(array, element => element === item);
+    }
+
+    /** Remove the *first* element satisfying `predicate`. */
+    function unorderedRemoveFirstItemWhere<T>(array: T[], predicate: (element: T) => boolean): void {
+        for (let i = 0; i < array.length; i++) {
+            if (predicate(array[i])) {
+                unorderedRemoveItemAt(array, i);
+                break;
+            }
+        }
+    }
+
+    export function createGetCanonicalFileName(useCaseSensitiveFileNames: boolean): (fileName: string) => string {
+        return useCaseSensitiveFileNames
             ? ((fileName) => fileName)
             : ((fileName) => fileName.toLowerCase());
     }
 
+    /**
+     * patternStrings contains both pattern strings (containing "*") and regular strings.
+     * Return an exact match if possible, or a pattern match, or undefined.
+     * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
+     */
+    /* @internal */
+    export function matchPatternOrExact(patternStrings: string[], candidate: string): string | Pattern | undefined {
+        const patterns: Pattern[] = [];
+        for (const patternString of patternStrings) {
+            const pattern = tryParsePattern(patternString);
+            if (pattern) {
+                patterns.push(pattern);
+            }
+            else if (patternString === candidate) {
+                // pattern was matched as is - no need to search further
+                return patternString;
+            }
+        }
+
+        return findBestPatternMatch(patterns, _ => _, candidate);
+    }
+
+    /* @internal */
+    export function patternText({prefix, suffix}: Pattern): string {
+        return `${prefix}*${suffix}`;
+    }
+
+    /**
+     * Given that candidate matches pattern, returns the text matching the '*'.
+     * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
+     */
+    /* @internal */
+    export function matchedText(pattern: Pattern, candidate: string): string {
+        Debug.assert(isPatternMatch(pattern, candidate));
+        return candidate.substr(pattern.prefix.length, candidate.length - pattern.suffix.length);
+    }
+
+    /** Return the object corresponding to the best pattern to match `candidate`. */
+    /* @internal */
+    export function findBestPatternMatch<T>(values: T[], getPattern: (value: T) => Pattern, candidate: string): T | undefined {
+        let matchedValue: T | undefined = undefined;
+        // use length of prefix as betterness criteria
+        let longestMatchPrefixLength = -1;
+
+        for (const v of values) {
+            const pattern = getPattern(v);
+            if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
+                longestMatchPrefixLength = pattern.prefix.length;
+                matchedValue = v;
+            }
+        }
+
+        return matchedValue;
+    }
+
+    function isPatternMatch({prefix, suffix}: Pattern, candidate: string) {
+        return candidate.length >= prefix.length + suffix.length &&
+            startsWith(candidate, prefix) &&
+            endsWith(candidate, suffix);
+    }
+
+    /* @internal */
+    export function tryParsePattern(pattern: string): Pattern | undefined {
+        // This should be verified outside of here and a proper error thrown.
+        Debug.assert(hasZeroOrOneAsteriskCharacter(pattern));
+        const indexOfStar = pattern.indexOf("*");
+        return indexOfStar === -1 ? undefined : {
+            prefix: pattern.substr(0, indexOfStar),
+            suffix: pattern.substr(indexOfStar + 1)
+        };
+    }
+
+    export function positionIsSynthesized(pos: number): boolean {
+        // This is a fast way of testing the following conditions:
+        //  pos === undefined || pos === null || isNaN(pos) || pos < 0;
+        return !(pos >= 0);
+    }
 }

src/compiler/declarationEmitter.ts

@@ -36,12 +36,12 @@ namespace ts {
         return declarationDiagnostics.getDiagnostics(targetSourceFile ? targetSourceFile.fileName : undefined);
 
         function getDeclarationDiagnosticsFromFile({ declarationFilePath }: EmitFileNames, sources: SourceFile[], isBundledEmit: boolean) {
-            emitDeclarations(host, resolver, declarationDiagnostics, declarationFilePath, sources, isBundledEmit);
+            emitDeclarations(host, resolver, declarationDiagnostics, declarationFilePath, sources, isBundledEmit, /*emitOnlyDtsFiles*/ false);
         }
     }
 
     function emitDeclarations(host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, declarationFilePath: string,
-        sourceFiles: SourceFile[], isBundledEmit: boolean): DeclarationEmit {
+        sourceFiles: SourceFile[], isBundledEmit: boolean, emitOnlyDtsFiles: boolean): DeclarationEmit {
         const newLine = host.getNewLine();
         const compilerOptions = host.getCompilerOptions();
 
@@ -98,7 +98,7 @@ namespace ts {
                         // global file reference is added only
                         //  - if it is not bundled emit (because otherwise it would be self reference)
                         //  - and it is not already added
-                        if (writeReferencePath(referencedFile, !isBundledEmit && !addedGlobalFileReference)) {
+                        if (writeReferencePath(referencedFile, !isBundledEmit && !addedGlobalFileReference, emitOnlyDtsFiles)) {
                             addedGlobalFileReference = true;
                         }
                         emittedReferencedFiles.push(referencedFile);
@@ -306,7 +306,7 @@ namespace ts {
         }
 
         function trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
-            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
+            handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ true));
             recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
         }
 
@@ -327,7 +327,7 @@ namespace ts {
             }
             else {
                 errorNameNode = declaration.name;
-                resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
                 errorNameNode = undefined;
             }
         }
@@ -341,7 +341,7 @@ namespace ts {
             }
             else {
                 errorNameNode = signature.name;
-                resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
                 errorNameNode = undefined;
             }
         }
@@ -374,7 +374,7 @@ namespace ts {
                 const jsDocComments = getJsDocCommentsFromText(declaration, currentText);
                 emitNewLineBeforeLeadingComments(currentLineMap, writer, declaration, jsDocComments);
                 // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
-                emitComments(currentText, currentLineMap, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
+                emitComments(currentText, currentLineMap, writer, jsDocComments, /*leadingSeparator*/ false, /*trailingSeparator*/ true, newLine, writeCommentRange);
             }
         }
 
@@ -563,7 +563,7 @@ namespace ts {
                 write(tempVarName);
                 write(": ");
                 writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic;
-                resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                resolver.writeTypeOfExpression(node.expression, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
                 write(";");
                 writeLine();
                 write(node.isExportEquals ? "export = " : "export default ");
@@ -655,12 +655,13 @@ namespace ts {
         function emitModuleElementDeclarationFlags(node: Node) {
             // If the node is parented in the current source file we need to emit export declare or just export
             if (node.parent.kind === SyntaxKind.SourceFile) {
+                const modifiers = getModifierFlags(node);
                 // If the node is exported
-                if (node.flags & NodeFlags.Export) {
+                if (modifiers & ModifierFlags.Export) {
                     write("export ");
                 }
 
-                if (node.flags & NodeFlags.Default) {
+                if (modifiers & ModifierFlags.Default) {
                     write("default ");
                 }
                 else if (node.kind !== SyntaxKind.InterfaceDeclaration && !noDeclare) {
@@ -669,21 +670,21 @@ namespace ts {
             }
         }
 
-        function emitClassMemberDeclarationFlags(flags: NodeFlags) {
-            if (flags & NodeFlags.Private) {
+        function emitClassMemberDeclarationFlags(flags: ModifierFlags) {
+            if (flags & ModifierFlags.Private) {
                 write("private ");
             }
-            else if (flags & NodeFlags.Protected) {
+            else if (flags & ModifierFlags.Protected) {
                 write("protected ");
             }
 
-            if (flags & NodeFlags.Static) {
+            if (flags & ModifierFlags.Static) {
                 write("static ");
             }
-            if (flags & NodeFlags.Readonly) {
+            if (flags & ModifierFlags.Readonly) {
                 write("readonly ");
             }
-            if (flags & NodeFlags.Abstract) {
+            if (flags & ModifierFlags.Abstract) {
                 write("abstract ");
             }
         }
@@ -692,7 +693,7 @@ namespace ts {
             // note usage of writer. methods instead of aliases created, just to make sure we are using
             // correct writer especially to handle asynchronous alias writing
             emitJsDocComments(node);
-            if (node.flags & NodeFlags.Export) {
+            if (hasModifier(node, ModifierFlags.Export)) {
                 write("export ");
             }
             write("import ");
@@ -731,7 +732,7 @@ namespace ts {
 
         function writeImportDeclaration(node: ImportDeclaration) {
             emitJsDocComments(node);
-            if (node.flags & NodeFlags.Export) {
+            if (hasModifier(node, ModifierFlags.Export)) {
                 write("export ");
             }
             write("import ");
@@ -926,7 +927,7 @@ namespace ts {
         }
 
         function isPrivateMethodTypeParameter(node: TypeParameterDeclaration) {
-            return node.parent.kind === SyntaxKind.MethodDeclaration && (node.parent.flags & NodeFlags.Private);
+            return node.parent.kind === SyntaxKind.MethodDeclaration && hasModifier(node.parent, ModifierFlags.Private);
         }
 
         function emitTypeParameters(typeParameters: TypeParameterDeclaration[]) {
@@ -976,7 +977,7 @@ namespace ts {
 
                         case SyntaxKind.MethodDeclaration:
                         case SyntaxKind.MethodSignature:
-                            if (node.parent.flags & NodeFlags.Static) {
+                            if (hasModifier(node.parent, ModifierFlags.Static)) {
                                 diagnosticMessage = Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
                             }
                             else if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
@@ -1025,7 +1026,7 @@ namespace ts {
                 }
                 else {
                     writer.getSymbolAccessibilityDiagnostic = getHeritageClauseVisibilityError;
-                    resolver.writeBaseConstructorTypeOfClass(<ClassLikeDeclaration>enclosingDeclaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                    resolver.writeBaseConstructorTypeOfClass(<ClassLikeDeclaration>enclosingDeclaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue, writer);
                 }
 
                 function getHeritageClauseVisibilityError(symbolAccessibilityResult: SymbolAccessibilityResult): SymbolAccessibilityDiagnostic {
@@ -1055,7 +1056,7 @@ namespace ts {
             function emitParameterProperties(constructorDeclaration: ConstructorDeclaration) {
                 if (constructorDeclaration) {
                     forEach(constructorDeclaration.parameters, param => {
-                        if (param.flags & NodeFlags.ParameterPropertyModifier) {
+                        if (hasModifier(param, ModifierFlags.ParameterPropertyModifier)) {
                             emitPropertyDeclaration(param);
                         }
                     });
@@ -1064,7 +1065,7 @@ namespace ts {
 
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
-            if (node.flags & NodeFlags.Abstract) {
+            if (hasModifier(node, ModifierFlags.Abstract)) {
                 write("abstract ");
             }
 
@@ -1114,13 +1115,13 @@ namespace ts {
             }
 
             emitJsDocComments(node);
-            emitClassMemberDeclarationFlags(node.flags);
+            emitClassMemberDeclarationFlags(getModifierFlags(node));
             emitVariableDeclaration(<VariableDeclaration>node);
             write(";");
             writeLine();
         }
 
-        function emitVariableDeclaration(node: VariableDeclaration) {
+        function emitVariableDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration) {
             // If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
             // so there is no check needed to see if declaration is visible
             if (node.kind !== SyntaxKind.VariableDeclaration || resolver.isDeclarationVisible(node)) {
@@ -1132,14 +1133,20 @@ namespace ts {
                     // it if it's not a well known symbol. In that case, the text of the name will be exactly
                     // what we want, namely the name expression enclosed in brackets.
                     writeTextOfNode(currentText, node.name);
-                    // If optional property emit ?
-                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature || node.kind === SyntaxKind.Parameter) && hasQuestionToken(node)) {
+                    // If optional property emit ? but in the case of parameterProperty declaration with "?" indicating optional parameter for the constructor
+                    // we don't want to emit property declaration with "?"
+                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature ||
+                        (node.kind === SyntaxKind.Parameter && !isParameterPropertyDeclaration(<ParameterDeclaration>node))) && hasQuestionToken(node)) {
                         write("?");
                     }
                     if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
                         emitTypeOfVariableDeclarationFromTypeLiteral(node);
                     }
-                    else if (!(node.flags & NodeFlags.Private)) {
+                    else if (resolver.isLiteralConstDeclaration(node)) {
+                        write(" = ");
+                        resolver.writeLiteralConstValue(node, writer);
+                    }
+                    else if (!hasModifier(node, ModifierFlags.Private)) {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
@@ -1156,7 +1163,7 @@ namespace ts {
                 // This check is to ensure we don't report error on constructor parameter property as that error would be reported during parameter emit
                 else if (node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) {
                     // TODO(jfreeman): Deal with computed properties in error reporting.
-                    if (node.flags & NodeFlags.Static) {
+                    if (hasModifier(node, ModifierFlags.Static)) {
                         return symbolAccessibilityResult.errorModuleName ?
                             symbolAccessibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                 Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -1267,9 +1274,9 @@ namespace ts {
             if (node === accessors.firstAccessor) {
                 emitJsDocComments(accessors.getAccessor);
                 emitJsDocComments(accessors.setAccessor);
-                emitClassMemberDeclarationFlags(node.flags | (accessors.setAccessor ? 0 : NodeFlags.Readonly));
+                emitClassMemberDeclarationFlags(getModifierFlags(node) | (accessors.setAccessor ? 0 : ModifierFlags.Readonly));
                 writeTextOfNode(currentText, node.name);
-                if (!(node.flags & NodeFlags.Private)) {
+                if (!hasModifier(node, ModifierFlags.Private)) {
                     accessorWithTypeAnnotation = node;
                     let type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
@@ -1300,7 +1307,7 @@ namespace ts {
                 let diagnosticMessage: DiagnosticMessage;
                 if (accessorWithTypeAnnotation.kind === SyntaxKind.SetAccessor) {
                     // Setters have to have type named and cannot infer it so, the type should always be named
-                    if (accessorWithTypeAnnotation.parent.flags & NodeFlags.Static) {
+                    if (hasModifier(accessorWithTypeAnnotation.parent, ModifierFlags.Static)) {
                         diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
                             Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2 :
                             Diagnostics.Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1;
@@ -1318,7 +1325,7 @@ namespace ts {
                     };
                 }
                 else {
-                    if (accessorWithTypeAnnotation.flags & NodeFlags.Static) {
+                    if (hasModifier(accessorWithTypeAnnotation, ModifierFlags.Static)) {
                         diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
                             symbolAccessibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                 Diagnostics.Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -1354,7 +1361,7 @@ namespace ts {
                     emitModuleElementDeclarationFlags(node);
                 }
                 else if (node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.Constructor) {
-                    emitClassMemberDeclarationFlags(node.flags);
+                    emitClassMemberDeclarationFlags(getModifierFlags(node));
                 }
                 if (node.kind === SyntaxKind.FunctionDeclaration) {
                     write("function ");
@@ -1385,7 +1392,7 @@ namespace ts {
 
             if (node.kind === SyntaxKind.IndexSignature) {
                 // Index signature can have readonly modifier
-                emitClassMemberDeclarationFlags(node.flags);
+                emitClassMemberDeclarationFlags(getModifierFlags(node));
                 write("[");
             }
             else {
@@ -1426,7 +1433,7 @@ namespace ts {
                     emitType(node.type);
                 }
             }
-            else if (node.kind !== SyntaxKind.Constructor && !(node.flags & NodeFlags.Private)) {
+            else if (node.kind !== SyntaxKind.Constructor && !hasModifier(node, ModifierFlags.Private)) {
                 writeReturnTypeAtSignature(node, getReturnTypeVisibilityError);
             }
 
@@ -1466,7 +1473,7 @@ namespace ts {
 
                     case SyntaxKind.MethodDeclaration:
                     case SyntaxKind.MethodSignature:
-                        if (node.flags & NodeFlags.Static) {
+                        if (hasModifier(node, ModifierFlags.Static)) {
                             diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
                                 symbolAccessibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                     Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named :
@@ -1532,7 +1539,7 @@ namespace ts {
                 node.parent.parent.kind === SyntaxKind.TypeLiteral) {
                 emitTypeOfVariableDeclarationFromTypeLiteral(node);
             }
-            else if (!(node.parent.flags & NodeFlags.Private)) {
+            else if (!hasModifier(node.parent, ModifierFlags.Private)) {
                 writeTypeOfDeclaration(node, node.type, getParameterDeclarationTypeVisibilityError);
             }
 
@@ -1568,7 +1575,7 @@ namespace ts {
 
                     case SyntaxKind.MethodDeclaration:
                     case SyntaxKind.MethodSignature:
-                        if (node.parent.flags & NodeFlags.Static) {
+                        if (hasModifier(node.parent, ModifierFlags.Static)) {
                             return symbolAccessibilityResult.errorModuleName ?
                                 symbolAccessibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
                                     Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
@@ -1619,8 +1626,7 @@ namespace ts {
                 }
             }
 
-            function emitBindingElement(bindingElement: BindingElement) {
-
+            function emitBindingElement(bindingElement: BindingElement | OmittedExpression) {
                 if (bindingElement.kind === SyntaxKind.OmittedExpression) {
                     // If bindingElement is an omittedExpression (i.e. containing elision),
                     // we will emit blank space (although this may differ from users' original code,
@@ -1713,7 +1719,7 @@ namespace ts {
          * @param referencedFile
          * @param addBundledFileReference Determines if global file reference corresponding to bundled file should be emitted or not
          */
-        function writeReferencePath(referencedFile: SourceFile, addBundledFileReference: boolean): boolean {
+        function writeReferencePath(referencedFile: SourceFile, addBundledFileReference: boolean, emitOnlyDtsFiles: boolean): boolean {
             let declFileName: string;
             let addedBundledEmitReference = false;
             if (isDeclarationFile(referencedFile)) {
@@ -1722,7 +1728,7 @@ namespace ts {
             }
             else {
                 // Get the declaration file path
-                forEachExpectedEmitFile(host, getDeclFileName, referencedFile);
+                forEachExpectedEmitFile(host, getDeclFileName, referencedFile, emitOnlyDtsFiles);
             }
 
             if (declFileName) {
@@ -1751,8 +1757,8 @@ namespace ts {
     }
 
     /* @internal */
-    export function writeDeclarationFile(declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection) {
-        const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit);
+    export function writeDeclarationFile(declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, emitOnlyDtsFiles: boolean) {
+        const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit, emitOnlyDtsFiles);
         const emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath) || host.getCompilerOptions().noEmit;
         if (!emitSkipped) {
             const declarationOutput = emitDeclarationResult.referencesOutput

src/compiler/diagnosticMessages.json

@@ -819,6 +819,10 @@
         "category": "Error",
         "code": 1253
     },
+    "A 'const' initializer in an ambient context must be a string or numeric literal.": {
+        "category": "Error",
+        "code": 1254
+    },
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
         "code": 1300
@@ -827,10 +831,6 @@
         "category": "Error",
         "code": 1308
     },
-    "Async functions are only available when targeting ECMAScript 2015 or higher.": {
-        "category": "Error",
-        "code": 1311
-    },
     "'=' can only be used in an object literal property inside a destructuring assignment.": {
         "category": "Error",
         "code": 1312
@@ -1047,7 +1047,7 @@
         "category": "Error",
         "code": 2348
     },
-    "Cannot invoke an expression whose type lacks a call signature.": {
+    "Cannot invoke an expression whose type lacks a call signature. Type '{0}' has no compatible call signatures.": {
         "category": "Error",
         "code": 2349
     },
@@ -1067,10 +1067,6 @@
         "category": "Error",
         "code": 2353
     },
-    "No best common type exists among return expressions.": {
-        "category": "Error",
-        "code": 2354
-    },
     "A function whose declared type is neither 'void' nor 'any' must return a value.": {
         "category": "Error",
         "code": 2355
@@ -1283,7 +1279,7 @@
         "category": "Error",
         "code": 2409
     },
-    "All symbols within a 'with' block will be resolved to 'any'.": {
+    "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'.": {
         "category": "Error",
         "code": 2410
     },
@@ -1635,10 +1631,6 @@
         "category": "Error",
         "code": 2503
     },
-    "No best common type exists among yield expressions.": {
-        "category": "Error",
-        "code": 2504
-    },
     "A generator cannot have a 'void' type annotation.": {
         "category": "Error",
         "code": 2505
@@ -1703,7 +1695,7 @@
         "category": "Error",
         "code": 2521
     },
-    "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression.": {
+    "The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method.": {
         "category": "Error",
         "code": 2522
     },
@@ -1931,7 +1923,7 @@
         "category": "Error",
         "code": 2685
     },
-    "Identifier '{0}' must be imported from a module": {
+    "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead.": {
         "category": "Error",
         "code": 2686
     },
@@ -1955,10 +1947,30 @@
         "category": "Error",
         "code": 2691
     },
-    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
+    "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible.": {
         "category": "Error",
         "code": 2692
     },
+    "'{0}' only refers to a type, but is being used as a value here.": {
+        "category": "Error",
+        "code": 2693
+    },
+    "Namespace '{0}' has no exported member '{1}'.": {
+        "category": "Error",
+        "code": 2694
+    },
+    "Left side of comma operator is unused and has no side effects.": {
+        "category": "Error",
+        "code": 2695
+    },
+    "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?": {
+        "category": "Error",
+        "code": 2696
+    },
+    "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'.": {
+        "category": "Error",
+        "code": 2697
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2475,6 +2487,10 @@
         "category": "Message",
         "code": 6038
     },
+    "STRATEGY": {
+        "category": "Message",
+        "code": 6039
+    },
     "Compilation complete. Watching for file changes.": {
         "category": "Message",
         "code": 6042
@@ -2839,6 +2855,18 @@
         "category": "Error",
         "code": 6138
     },
+    "Import emit helpers from 'tslib'.": {
+        "category": "Message",
+        "code": 6139
+    },
+    "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'.": {
+        "category": "Error",
+        "code": 6140
+    },
+    "Parse in strict mode and emit \"use strict\" for each source file": {
+        "category": "Message",
+        "code": 6141
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005
@@ -2871,10 +2899,6 @@
         "category": "Error",
         "code": 7015
     },
-    "Property '{0}' implicitly has type 'any', because its 'set' accessor lacks a type annotation.": {
-        "category": "Error",
-        "code": 7016
-    },
     "Index signature of object type implicitly has an 'any' type.": {
         "category": "Error",
         "code": 7017
@@ -2931,6 +2955,18 @@
         "category": "Error",
         "code": 7031
     },
+    "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation.": {
+        "category": "Error",
+        "code": 7032
+    },
+    "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation.": {
+        "category": "Error",
+        "code": 7033
+    },
+    "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined.": {
+        "category": "Error",
+        "code": 7034
+    },
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000
@@ -3042,5 +3078,41 @@
     "Unknown typing option '{0}'.": {
         "category": "Error",
         "code": 17010
+    },
+    "Circularity detected while resolving configuration: {0}": {
+        "category": "Error",
+        "code": 18000
+    },
+    "The path in an 'extends' options must be relative or rooted.": {
+        "category": "Error",
+        "code": 18001
+    },
+    "Add missing 'super()' call.": {
+        "category": "Message",
+        "code": 90001
+    },
+    "Make 'super()' call the first statement in the constructor.": {
+        "category": "Message",
+        "code": 90002
+    },
+    "Change 'extends' to 'implements'": {
+        "category": "Message",
+        "code": 90003
+    },
+    "Remove unused identifiers": {
+        "category": "Message",
+        "code": 90004
+    },
+    "Implement interface on reference": {
+        "category": "Message",
+        "code": 90005
+    },
+    "Implement interface on class": {
+        "category": "Message",
+        "code": 90006
+    },
+    "Implement inherited abstract class": {
+        "category": "Message",
+        "code": 90007
     }
 }

src/compiler/moduleNameResolver.ts

@@ -0,0 +1,761 @@
+/// <reference path="core.ts" />
+/// <reference path="diagnosticInformationMap.generated.ts" />
+
+namespace ts {
+
+    /* @internal */
+    export function trace(host: ModuleResolutionHost, message: DiagnosticMessage, ...args: any[]): void;
+    export function trace(host: ModuleResolutionHost, message: DiagnosticMessage): void {
+        host.trace(formatMessage.apply(undefined, arguments));
+    }
+
+    /* @internal */
+    export function isTraceEnabled(compilerOptions: CompilerOptions, host: ModuleResolutionHost): boolean {
+        return compilerOptions.traceResolution && host.trace !== undefined;
+    }
+
+    /* @internal */
+    export function createResolvedModule(resolvedFileName: string, isExternalLibraryImport: boolean, failedLookupLocations: string[]): ResolvedModuleWithFailedLookupLocations {
+        return { resolvedModule: resolvedFileName ? { resolvedFileName, isExternalLibraryImport } : undefined, failedLookupLocations };
+    }
+
+    function moduleHasNonRelativeName(moduleName: string): boolean {
+        return !(isRootedDiskPath(moduleName) || isExternalModuleNameRelative(moduleName));
+    }
+
+    /* @internal */
+    export interface ModuleResolutionState {
+        host: ModuleResolutionHost;
+        compilerOptions: CompilerOptions;
+        traceEnabled: boolean;
+        // skip .tsx files if jsx is not enabled
+        skipTsx: boolean;
+    }
+
+    function tryReadTypesSection(packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
+        const jsonContent = readJson(packageJsonPath, state.host);
+
+        function tryReadFromField(fieldName: string) {
+            if (hasProperty(jsonContent, fieldName)) {
+                const typesFile = (<any>jsonContent)[fieldName];
+                if (typeof typesFile === "string") {
+                    const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
+                    }
+                    return typesFilePath;
+                }
+                else {
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, fieldName, typeof typesFile);
+                    }
+                }
+            }
+        }
+
+        const typesFilePath = tryReadFromField("typings") || tryReadFromField("types");
+        if (typesFilePath) {
+            return typesFilePath;
+        }
+
+        // Use the main module for inferring types if no types package specified and the allowJs is set
+        if (state.compilerOptions.allowJs && jsonContent.main && typeof jsonContent.main === "string") {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.No_types_specified_in_package_json_but_allowJs_is_set_so_returning_main_value_of_0, jsonContent.main);
+            }
+            const mainFilePath = normalizePath(combinePaths(baseDirectory, jsonContent.main));
+            return mainFilePath;
+        }
+        return undefined;
+    }
+
+    function readJson(path: string, host: ModuleResolutionHost): { typings?: string, types?: string, main?: string } {
+        try {
+            const jsonText = host.readFile(path);
+            return jsonText ? JSON.parse(jsonText) : {};
+        }
+        catch (e) {
+            // gracefully handle if readFile fails or returns not JSON
+            return {};
+        }
+    }
+
+    const typeReferenceExtensions = [".d.ts"];
+
+    export function getEffectiveTypeRoots(options: CompilerOptions, host: { directoryExists?: (directoryName: string) => boolean, getCurrentDirectory?: () => string }): string[] | undefined {
+        if (options.typeRoots) {
+            return options.typeRoots;
+        }
+
+        let currentDirectory: string;
+        if (options.configFilePath) {
+            currentDirectory = getDirectoryPath(options.configFilePath);
+        }
+        else if (host.getCurrentDirectory) {
+            currentDirectory = host.getCurrentDirectory();
+        }
+
+        return currentDirectory !== undefined && getDefaultTypeRoots(currentDirectory, host);
+    }
+
+    /**
+     * Returns the path to every node_modules/@types directory from some ancestor directory.
+     * Returns undefined if there are none.
+     */
+    function getDefaultTypeRoots(currentDirectory: string, host: { directoryExists?: (directoryName: string) => boolean }): string[] | undefined {
+        if (!host.directoryExists) {
+            return [combinePaths(currentDirectory, nodeModulesAtTypes)];
+            // And if it doesn't exist, tough.
+        }
+
+        let typeRoots: string[];
+
+        while (true) {
+            const atTypes = combinePaths(currentDirectory, nodeModulesAtTypes);
+            if (host.directoryExists(atTypes)) {
+                (typeRoots || (typeRoots = [])).push(atTypes);
+            }
+
+            const parent = getDirectoryPath(currentDirectory);
+            if (parent === currentDirectory) {
+                break;
+            }
+            currentDirectory = parent;
+        }
+
+        return typeRoots;
+    }
+    const nodeModulesAtTypes = combinePaths("node_modules", "@types");
+
+    /**
+     * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
+     * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
+     * is assumed to be the same as root directory of the project.
+     */
+    export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
+        const traceEnabled = isTraceEnabled(options, host);
+        const moduleResolutionState: ModuleResolutionState = {
+            compilerOptions: options,
+            host: host,
+            skipTsx: true,
+            traceEnabled
+        };
+
+        const typeRoots = getEffectiveTypeRoots(options, host);
+        if (traceEnabled) {
+            if (containingFile === undefined) {
+                if (typeRoots === undefined) {
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
+                }
+                else {
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
+                }
+            }
+            else {
+                if (typeRoots === undefined) {
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
+                }
+                else {
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
+                }
+            }
+        }
+
+        const failedLookupLocations: string[] = [];
+
+        // Check primary library paths
+        if (typeRoots && typeRoots.length) {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
+            }
+            const primarySearchPaths = typeRoots;
+            for (const typeRoot of primarySearchPaths) {
+                const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
+                const candidateDirectory = getDirectoryPath(candidate);
+                const resolvedFile = loadNodeModuleFromDirectory(typeReferenceExtensions, candidate, failedLookupLocations,
+                    !directoryProbablyExists(candidateDirectory, host), moduleResolutionState);
+
+                if (resolvedFile) {
+                    if (traceEnabled) {
+                        trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, true);
+                    }
+                    return {
+                        resolvedTypeReferenceDirective: { primary: true, resolvedFileName: resolvedFile },
+                        failedLookupLocations
+                    };
+                }
+            }
+        }
+        else {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
+            }
+        }
+
+        let resolvedFile: string;
+        let initialLocationForSecondaryLookup: string;
+        if (containingFile) {
+            initialLocationForSecondaryLookup = getDirectoryPath(containingFile);
+        }
+
+        if (initialLocationForSecondaryLookup !== undefined) {
+            // check secondary locations
+            if (traceEnabled) {
+                trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
+            }
+            resolvedFile = loadModuleFromNodeModules(typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState, /*checkOneLevel*/ false);
+            if (traceEnabled) {
+                if (resolvedFile) {
+                    trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, false);
+                }
+                else {
+                    trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
+                }
+            }
+        }
+        else {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
+            }
+        }
+        return {
+            resolvedTypeReferenceDirective: resolvedFile
+                ? { primary: false, resolvedFileName: resolvedFile }
+                : undefined,
+            failedLookupLocations
+        };
+    }
+
+    /**
+      * Given a set of options, returns the set of type directive names
+      *   that should be included for this program automatically.
+      * This list could either come from the config file,
+      *   or from enumerating the types root + initial secondary types lookup location.
+      * More type directives might appear in the program later as a result of loading actual source files;
+      *   this list is only the set of defaults that are implicitly included.
+      */
+    export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[] {
+        // Use explicit type list from tsconfig.json
+        if (options.types) {
+            return options.types;
+        }
+
+        // Walk the primary type lookup locations
+        const result: string[] = [];
+        if (host.directoryExists && host.getDirectories) {
+            const typeRoots = getEffectiveTypeRoots(options, host);
+            if (typeRoots) {
+                for (const root of typeRoots) {
+                    if (host.directoryExists(root)) {
+                        for (const typeDirectivePath of host.getDirectories(root)) {
+                            const normalized = normalizePath(typeDirectivePath);
+                            const packageJsonPath = pathToPackageJson(combinePaths(root, normalized));
+                            // tslint:disable-next-line:no-null-keyword
+                            const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
+                            if (!isNotNeededPackage) {
+                                // Return just the type directive names
+                                result.push(getBaseFileName(normalized));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+        const traceEnabled = isTraceEnabled(compilerOptions, host);
+        if (traceEnabled) {
+            trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
+        }
+
+        let moduleResolution = compilerOptions.moduleResolution;
+        if (moduleResolution === undefined) {
+            moduleResolution = getEmitModuleKind(compilerOptions) === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic;
+            if (traceEnabled) {
+                trace(host, Diagnostics.Module_resolution_kind_is_not_specified_using_0, ModuleResolutionKind[moduleResolution]);
+            }
+        }
+        else {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ModuleResolutionKind[moduleResolution]);
+            }
+        }
+
+        let result: ResolvedModuleWithFailedLookupLocations;
+        switch (moduleResolution) {
+            case ModuleResolutionKind.NodeJs:
+                result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host);
+                break;
+            case ModuleResolutionKind.Classic:
+                result = classicNameResolver(moduleName, containingFile, compilerOptions, host);
+                break;
+        }
+
+        if (traceEnabled) {
+            if (result.resolvedModule) {
+                trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
+            }
+            else {
+                trace(host, Diagnostics.Module_name_0_was_not_resolved, moduleName);
+            }
+        }
+
+        return result;
+    }
+
+    /*
+     * Every module resolution kind can has its specific understanding how to load module from a specific path on disk
+     * I.e. for path '/a/b/c':
+     * - Node loader will first to try to check if '/a/b/c' points to a file with some supported extension and if this fails
+     * it will try to load module from directory: directory '/a/b/c' should exist and it should have either 'package.json' with
+     * 'typings' entry or file 'index' with some supported extension
+     * - Classic loader will only try to interpret '/a/b/c' as file.
+     */
+    type ResolutionKindSpecificLoader = (candidate: string, extensions: string[], failedLookupLocations: string[], onlyRecordFailures: boolean, state: ModuleResolutionState) => string;
+
+    /**
+     * Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to
+     * mitigate differences between design time structure of the project and its runtime counterpart so the same import name
+     * can be resolved successfully by TypeScript compiler and runtime module loader.
+     * If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will
+     * fallback to standard resolution routine.
+     *
+     * - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative
+     * names will be resolved relative to baseUrl: i.e. if baseUrl is '/a/b' then candidate location to resolve module name 'c/d' will
+     * be '/a/b/c/d'
+     * - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names
+     * will be resolved based on the content of the module name.
+     * Structure of 'paths' compiler options
+     * 'paths': {
+     *    pattern-1: [...substitutions],
+     *    pattern-2: [...substitutions],
+     *    ...
+     *    pattern-n: [...substitutions]
+     * }
+     * Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against
+     * all patterns in the list. Matching for patterns that don't contain '*' means that module name must be equal to pattern respecting the case.
+     * If pattern contains '*' then to match pattern "<prefix>*<suffix>" module name must start with the <prefix> and end with <suffix>.
+     * <MatchedStar> denotes part of the module name between <prefix> and <suffix>.
+     * If module name can be matches with multiple patterns then pattern with the longest prefix will be picked.
+     * After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module
+     * from the candidate location.
+     * Substitution is a string that can contain zero or one '*'. To get candidate location from substitution we'll pick every
+     * substitution in the list and replace '*' with <MatchedStar> string. If candidate location is not rooted it
+     * will be converted to absolute using baseUrl.
+     * For example:
+     * baseUrl: /a/b/c
+     * "paths": {
+     *     // match all module names
+     *     "*": [
+     *         "*",        // use matched name as is,
+     *                     // <matched name> will be looked as /a/b/c/<matched name>
+     *
+     *         "folder1/*" // substitution will convert matched name to 'folder1/<matched name>',
+     *                     // since it is not rooted then final candidate location will be /a/b/c/folder1/<matched name>
+     *     ],
+     *     // match module names that start with 'components/'
+     *     "components/*": [ "/root/components/*" ] // substitution will convert /components/folder1/<matched name> to '/root/components/folder1/<matched name>',
+     *                                              // it is rooted so it will be final candidate location
+     * }
+     *
+     * 'rootDirs' allows the project to be spreaded across multiple locations and resolve modules with relative names as if
+     * they were in the same location. For example lets say there are two files
+     * '/local/src/content/file1.ts'
+     * '/shared/components/contracts/src/content/protocols/file2.ts'
+     * After bundling content of '/shared/components/contracts/src' will be merged with '/local/src' so
+     * if file1 has the following import 'import {x} from "./protocols/file2"' it will be resolved successfully in runtime.
+     * 'rootDirs' provides the way to tell compiler that in order to get the whole project it should behave as if content of all
+     * root dirs were merged together.
+     * I.e. for the example above 'rootDirs' will have two entries: [ '/local/src', '/shared/components/contracts/src' ].
+     * Compiler will first convert './protocols/file2' into absolute path relative to the location of containing file:
+     * '/local/src/content/protocols/file2' and try to load it - failure.
+     * Then it will search 'rootDirs' looking for a longest matching prefix of this absolute path and if such prefix is found - absolute path will
+     * be converted to a path relative to found rootDir entry './content/protocols/file2' (*). As a last step compiler will check all remaining
+     * entries in 'rootDirs', use them to build absolute path out of (*) and try to resolve module from this location.
+     */
+    function tryLoadModuleUsingOptionalResolutionSettings(moduleName: string, containingDirectory: string, loader: ResolutionKindSpecificLoader,
+        failedLookupLocations: string[], supportedExtensions: string[], state: ModuleResolutionState): string {
+
+        if (moduleHasNonRelativeName(moduleName)) {
+            return tryLoadModuleUsingBaseUrl(moduleName, loader, failedLookupLocations, supportedExtensions, state);
+        }
+        else {
+            return tryLoadModuleUsingRootDirs(moduleName, containingDirectory, loader, failedLookupLocations, supportedExtensions, state);
+        }
+    }
+
+    function tryLoadModuleUsingRootDirs(moduleName: string, containingDirectory: string, loader: ResolutionKindSpecificLoader,
+        failedLookupLocations: string[], supportedExtensions: string[], state: ModuleResolutionState): string {
+
+        if (!state.compilerOptions.rootDirs) {
+            return undefined;
+        }
+
+        if (state.traceEnabled) {
+            trace(state.host, Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
+        }
+
+        const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
+
+        let matchedRootDir: string;
+        let matchedNormalizedPrefix: string;
+        for (const rootDir of state.compilerOptions.rootDirs) {
+            // rootDirs are expected to be absolute
+            // in case of tsconfig.json this will happen automatically - compiler will expand relative names
+            // using location of tsconfig.json as base location
+            let normalizedRoot = normalizePath(rootDir);
+            if (!endsWith(normalizedRoot, directorySeparator)) {
+                normalizedRoot += directorySeparator;
+            }
+            const isLongestMatchingPrefix =
+                startsWith(candidate, normalizedRoot) &&
+                (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length);
+
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);
+            }
+
+            if (isLongestMatchingPrefix) {
+                matchedNormalizedPrefix = normalizedRoot;
+                matchedRootDir = rootDir;
+            }
+        }
+        if (matchedNormalizedPrefix) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
+            }
+            const suffix = candidate.substr(matchedNormalizedPrefix.length);
+
+            // first - try to load from a initial location
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
+            }
+            const resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(containingDirectory, state.host), state);
+            if (resolvedFileName) {
+                return resolvedFileName;
+            }
+
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Trying_other_entries_in_rootDirs);
+            }
+            // then try to resolve using remaining entries in rootDirs
+            for (const rootDir of state.compilerOptions.rootDirs) {
+                if (rootDir === matchedRootDir) {
+                    // skip the initially matched entry
+                    continue;
+                }
+                const candidate = combinePaths(normalizePath(rootDir), suffix);
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate);
+                }
+                const baseDirectory = getDirectoryPath(candidate);
+                const resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(baseDirectory, state.host), state);
+                if (resolvedFileName) {
+                    return resolvedFileName;
+                }
+            }
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Module_resolution_using_rootDirs_has_failed);
+            }
+        }
+        return undefined;
+    }
+
+    function tryLoadModuleUsingBaseUrl(moduleName: string, loader: ResolutionKindSpecificLoader, failedLookupLocations: string[],
+        supportedExtensions: string[], state: ModuleResolutionState): string {
+
+        if (!state.compilerOptions.baseUrl) {
+            return undefined;
+        }
+        if (state.traceEnabled) {
+            trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, state.compilerOptions.baseUrl, moduleName);
+        }
+
+        // string is for exact match
+        let matchedPattern: Pattern | string | undefined = undefined;
+        if (state.compilerOptions.paths) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
+            }
+            matchedPattern = matchPatternOrExact(getOwnKeys(state.compilerOptions.paths), moduleName);
+        }
+
+        if (matchedPattern) {
+            const matchedStar = typeof matchedPattern === "string" ? undefined : matchedText(matchedPattern, moduleName);
+            const matchedPatternText = typeof matchedPattern === "string" ? matchedPattern : patternText(matchedPattern);
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
+            }
+            for (const subst of state.compilerOptions.paths[matchedPatternText]) {
+                const path = matchedStar ? subst.replace("*", matchedStar) : subst;
+                const candidate = normalizePath(combinePaths(state.compilerOptions.baseUrl, path));
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
+                }
+                const resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
+                if (resolvedFileName) {
+                    return resolvedFileName;
+                }
+            }
+            return undefined;
+        }
+        else {
+            const candidate = normalizePath(combinePaths(state.compilerOptions.baseUrl, moduleName));
+
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, state.compilerOptions.baseUrl, candidate);
+            }
+
+            return loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
+        }
+    }
+
+    export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+        const containingDirectory = getDirectoryPath(containingFile);
+        const supportedExtensions = getSupportedExtensions(compilerOptions);
+        const traceEnabled = isTraceEnabled(compilerOptions, host);
+
+        const failedLookupLocations: string[] = [];
+        const state = { compilerOptions, host, traceEnabled, skipTsx: false };
+        let resolvedFileName = tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, nodeLoadModuleByRelativeName,
+            failedLookupLocations, supportedExtensions, state);
+
+        let isExternalLibraryImport = false;
+        if (!resolvedFileName) {
+            if (moduleHasNonRelativeName(moduleName)) {
+                if (traceEnabled) {
+                    trace(host, Diagnostics.Loading_module_0_from_node_modules_folder, moduleName);
+                }
+                resolvedFileName = loadModuleFromNodeModules(moduleName, containingDirectory, failedLookupLocations, state, /*checkOneLevel*/ false);
+                isExternalLibraryImport = resolvedFileName !== undefined;
+            }
+            else {
+                const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
+                resolvedFileName = nodeLoadModuleByRelativeName(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+            }
+        }
+
+        if (resolvedFileName && host.realpath) {
+            const originalFileName = resolvedFileName;
+            resolvedFileName = normalizePath(host.realpath(resolvedFileName));
+            if (traceEnabled) {
+                trace(host, Diagnostics.Resolving_real_path_for_0_result_1, originalFileName, resolvedFileName);
+            }
+        }
+
+        return createResolvedModule(resolvedFileName, isExternalLibraryImport, failedLookupLocations);
+    }
+
+    function nodeLoadModuleByRelativeName(candidate: string, supportedExtensions: string[], failedLookupLocations: string[],
+        onlyRecordFailures: boolean, state: ModuleResolutionState): string {
+
+        if (state.traceEnabled) {
+            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
+        }
+
+        const resolvedFileName = !pathEndsWithDirectorySeparator(candidate) && loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, onlyRecordFailures, state);
+
+        return resolvedFileName || loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, onlyRecordFailures, state);
+    }
+
+    /* @internal */
+    export function directoryProbablyExists(directoryName: string, host: { directoryExists?: (directoryName: string) => boolean }): boolean {
+        // if host does not support 'directoryExists' assume that directory will exist
+        return !host.directoryExists || host.directoryExists(directoryName);
+    }
+
+    /**
+     * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
+     * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
+     */
+    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        // First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts"
+        const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
+        if (resolvedByAddingExtension) {
+            return resolvedByAddingExtension;
+        }
+
+        // If that didn't work, try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one;
+        // e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
+        if (hasJavaScriptFileExtension(candidate)) {
+            const extensionless = removeFileExtension(candidate);
+            if (state.traceEnabled) {
+                const extension = candidate.substring(extensionless.length);
+                trace(state.host, Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
+            }
+            return tryAddingExtensions(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
+        }
+    }
+
+    /** Try to return an existing file that adds one of the `extensions` to `candidate`. */
+    function tryAddingExtensions(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        if (!onlyRecordFailures) {
+            // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
+            const directory = getDirectoryPath(candidate);
+            if (directory) {
+                onlyRecordFailures = !directoryProbablyExists(directory, state.host);
+            }
+        }
+        return forEach(extensions, ext =>
+            !(state.skipTsx && isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state));
+    }
+
+    /** Return the file if it exists. */
+    function tryFile(fileName: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
+        if (!onlyRecordFailures && state.host.fileExists(fileName)) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
+            }
+            return fileName;
+        }
+        else {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
+            }
+            failedLookupLocation.push(fileName);
+            return undefined;
+        }
+    }
+
+    function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
+        const packageJsonPath = pathToPackageJson(candidate);
+        const directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, state.host);
+        if (directoryExists && state.host.fileExists(packageJsonPath)) {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.Found_package_json_at_0, packageJsonPath);
+            }
+            const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
+            if (typesFile) {
+                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures, state);
+                if (result) {
+                    return result;
+                }
+            }
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.package_json_does_not_have_types_field);
+                }
+            }
+        }
+        else {
+            if (state.traceEnabled) {
+                trace(state.host, Diagnostics.File_0_does_not_exist, packageJsonPath);
+            }
+            // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results
+            failedLookupLocation.push(packageJsonPath);
+        }
+
+        return loadModuleFromFile(combinePaths(candidate, "index"), extensions, failedLookupLocation, !directoryExists, state);
+    }
+
+    function pathToPackageJson(directory: string): string {
+        return combinePaths(directory, "package.json");
+    }
+
+    function loadModuleFromNodeModulesFolder(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
+        const nodeModulesFolder = combinePaths(directory, "node_modules");
+        const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
+        const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
+        const supportedExtensions = getSupportedExtensions(state.compilerOptions);
+
+        let result = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, !nodeModulesFolderExists, state);
+        if (result) {
+            return result;
+        }
+        result = loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state);
+        if (result) {
+            return result;
+        }
+    }
+
+    /* @internal */
+    export function loadModuleFromNodeModules(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState, checkOneLevel: boolean): string {
+        return loadModuleFromNodeModulesWorker(moduleName, directory, failedLookupLocations, state, checkOneLevel, /*typesOnly*/ false);
+    }
+
+    function loadModuleFromNodeModulesAtTypes(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
+        return loadModuleFromNodeModulesWorker(moduleName, directory, failedLookupLocations, state, /*checkOneLevel*/ false, /*typesOnly*/ true);
+    }
+
+    function loadModuleFromNodeModulesWorker(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState, checkOneLevel: boolean, typesOnly: boolean): string {
+        directory = normalizeSlashes(directory);
+        while (true) {
+            const baseName = getBaseFileName(directory);
+            if (baseName !== "node_modules") {
+                let packageResult: string | undefined;
+                if (!typesOnly) {
+                    // Try to load source from the package
+                    packageResult = loadModuleFromNodeModulesFolder(moduleName, directory, failedLookupLocations, state);
+                    if (packageResult && hasTypeScriptFileExtension(packageResult)) {
+                        // Always prefer a TypeScript (.ts, .tsx, .d.ts) file shipped with the package
+                        return packageResult;
+                    }
+                }
+
+                // Else prefer a types package over non-TypeScript results (e.g. JavaScript files)
+                const typesResult = loadModuleFromNodeModulesFolder(combinePaths("@types", moduleName), directory, failedLookupLocations, state);
+                if (typesResult || packageResult) {
+                    return typesResult || packageResult;
+                }
+            }
+
+            const parentPath = getDirectoryPath(directory);
+            if (parentPath === directory || checkOneLevel) {
+                break;
+            }
+
+            directory = parentPath;
+        }
+        return undefined;
+    }
+
+    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+        const traceEnabled = isTraceEnabled(compilerOptions, host);
+        const state = { compilerOptions, host, traceEnabled, skipTsx: !compilerOptions.jsx };
+        const failedLookupLocations: string[] = [];
+        const supportedExtensions = getSupportedExtensions(compilerOptions);
+        const containingDirectory = getDirectoryPath(containingFile);
+
+        const resolvedFileName = tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, loadModuleFromFile, failedLookupLocations, supportedExtensions, state);
+        if (resolvedFileName) {
+            return createResolvedModule(resolvedFileName, /*isExternalLibraryImport*/false, failedLookupLocations);
+        }
+
+        let referencedSourceFile: string;
+        if (moduleHasNonRelativeName(moduleName)) {
+            referencedSourceFile = referencedSourceFile = loadModuleFromAncestorDirectories(moduleName, containingDirectory, supportedExtensions, failedLookupLocations, state) ||
+                // If we didn't find the file normally, look it up in @types.
+                loadModuleFromNodeModulesAtTypes(moduleName, containingDirectory, failedLookupLocations, state);
+        }
+        else {
+            const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
+            referencedSourceFile = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+        }
+
+
+        return referencedSourceFile
+            ? { resolvedModule: { resolvedFileName: referencedSourceFile }, failedLookupLocations }
+            : { resolvedModule: undefined, failedLookupLocations };
+    }
+
+    /** Climb up parent directories looking for a module. */
+    function loadModuleFromAncestorDirectories(moduleName: string, containingDirectory: string, supportedExtensions: string[], failedLookupLocations: string[], state: ModuleResolutionState): string | undefined {
+        while (true) {
+            const searchName = normalizePath(combinePaths(containingDirectory, moduleName));
+            const referencedSourceFile = loadModuleFromFile(searchName, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+            if (referencedSourceFile) {
+                return referencedSourceFile;
+            }
+            const parentPath = getDirectoryPath(containingDirectory);
+            if (parentPath === containingDirectory) {
+                return undefined;
+            }
+            containingDirectory = parentPath;
+        }
+    }
+}

src/compiler/program.ts

@@ -4,15 +4,14 @@
 
 namespace ts {
     /** The version of the TypeScript compiler release */
+
     export const version = "2.1.0";
 
     const emptyArray: any[] = [];
 
-    const defaultTypeRoots = ["node_modules/@types"];
-
-    export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean): string {
+    export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName = "tsconfig.json"): string {
         while (true) {
-            const fileName = combinePaths(searchPath, "tsconfig.json");
+            const fileName = combinePaths(searchPath, configName);
             if (fileExists(fileName)) {
                 return fileName;
             }
@@ -76,761 +75,6 @@ namespace ts {
         return getNormalizedPathFromPathComponents(commonPathComponents);
     }
 
-    function trace(host: ModuleResolutionHost, message: DiagnosticMessage, ...args: any[]): void;
-    function trace(host: ModuleResolutionHost, message: DiagnosticMessage): void {
-        host.trace(formatMessage.apply(undefined, arguments));
-    }
-
-    function isTraceEnabled(compilerOptions: CompilerOptions, host: ModuleResolutionHost): boolean {
-        return compilerOptions.traceResolution && host.trace !== undefined;
-    }
-
-    /* @internal */
-    export function hasZeroOrOneAsteriskCharacter(str: string): boolean {
-        let seenAsterisk = false;
-        for (let i = 0; i < str.length; i++) {
-            if (str.charCodeAt(i) === CharacterCodes.asterisk) {
-                if (!seenAsterisk) {
-                    seenAsterisk = true;
-                }
-                else {
-                    // have already seen asterisk
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    function createResolvedModule(resolvedFileName: string, isExternalLibraryImport: boolean, failedLookupLocations: string[]): ResolvedModuleWithFailedLookupLocations {
-        return { resolvedModule: resolvedFileName ? { resolvedFileName, isExternalLibraryImport } : undefined, failedLookupLocations };
-    }
-
-    function moduleHasNonRelativeName(moduleName: string): boolean {
-        return !(isRootedDiskPath(moduleName) || isExternalModuleNameRelative(moduleName));
-    }
-
-    interface ModuleResolutionState {
-        host: ModuleResolutionHost;
-        compilerOptions: CompilerOptions;
-        traceEnabled: boolean;
-        // skip .tsx files if jsx is not enabled
-        skipTsx: boolean;
-    }
-
-    function tryReadTypesSection(packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
-        const jsonContent = readJson(packageJsonPath, state.host);
-
-        function tryReadFromField(fieldName: string) {
-            if (hasProperty(jsonContent, fieldName)) {
-                const typesFile = (<any>jsonContent)[fieldName];
-                if (typeof typesFile === "string") {
-                    const typesFilePath = normalizePath(combinePaths(baseDirectory, typesFile));
-                    if (state.traceEnabled) {
-                        trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, typesFile, typesFilePath);
-                    }
-                    return typesFilePath;
-                }
-                else {
-                    if (state.traceEnabled) {
-                        trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, fieldName, typeof typesFile);
-                    }
-                }
-            }
-        }
-
-        const typesFilePath = tryReadFromField("typings") || tryReadFromField("types");
-        if (typesFilePath) {
-            return typesFilePath;
-        }
-
-        // Use the main module for inferring types if no types package specified and the allowJs is set
-        if (state.compilerOptions.allowJs && jsonContent.main && typeof jsonContent.main === "string") {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.No_types_specified_in_package_json_but_allowJs_is_set_so_returning_main_value_of_0, jsonContent.main);
-            }
-            const mainFilePath = normalizePath(combinePaths(baseDirectory, jsonContent.main));
-            return mainFilePath;
-        }
-        return undefined;
-    }
-
-    function readJson(path: string, host: ModuleResolutionHost): { typings?: string, types?: string, main?: string } {
-        try {
-            const jsonText = host.readFile(path);
-            return jsonText ? JSON.parse(jsonText) : {};
-        }
-        catch (e) {
-            // gracefully handle if readFile fails or returns not JSON
-            return {};
-        }
-    }
-
-    const typeReferenceExtensions = [".d.ts"];
-
-    function getEffectiveTypeRoots(options: CompilerOptions, host: ModuleResolutionHost) {
-        if (options.typeRoots) {
-            return options.typeRoots;
-        }
-
-        let currentDirectory: string;
-        if (options.configFilePath) {
-            currentDirectory = getDirectoryPath(options.configFilePath);
-        }
-        else if (host.getCurrentDirectory) {
-            currentDirectory = host.getCurrentDirectory();
-        }
-
-        if (!currentDirectory) {
-            return undefined;
-        }
-        return map(defaultTypeRoots, d => combinePaths(currentDirectory, d));
-    }
-
-    /**
-     * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
-     * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
-     * is assumed to be the same as root directory of the project.
-     */
-    export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
-        const traceEnabled = isTraceEnabled(options, host);
-        const moduleResolutionState: ModuleResolutionState = {
-            compilerOptions: options,
-            host: host,
-            skipTsx: true,
-            traceEnabled
-        };
-
-        const typeRoots = getEffectiveTypeRoots(options, host);
-        if (traceEnabled) {
-            if (containingFile === undefined) {
-                if (typeRoots === undefined) {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
-                }
-                else {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
-                }
-            }
-            else {
-                if (typeRoots === undefined) {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
-                }
-                else {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
-                }
-            }
-        }
-
-        const failedLookupLocations: string[] = [];
-
-        // Check primary library paths
-        if (typeRoots && typeRoots.length) {
-            if (traceEnabled) {
-                trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
-            }
-            const primarySearchPaths = typeRoots;
-            for (const typeRoot of primarySearchPaths) {
-                const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
-                const candidateDirectory = getDirectoryPath(candidate);
-                const resolvedFile = loadNodeModuleFromDirectory(typeReferenceExtensions, candidate, failedLookupLocations,
-                    !directoryProbablyExists(candidateDirectory, host), moduleResolutionState);
-
-                if (resolvedFile) {
-                    if (traceEnabled) {
-                        trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, true);
-                    }
-                    return {
-                        resolvedTypeReferenceDirective: { primary: true, resolvedFileName: resolvedFile },
-                        failedLookupLocations
-                    };
-                }
-            }
-        }
-        else {
-            if (traceEnabled) {
-                trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
-            }
-        }
-
-        let resolvedFile: string;
-        let initialLocationForSecondaryLookup: string;
-        if (containingFile) {
-            initialLocationForSecondaryLookup = getDirectoryPath(containingFile);
-        }
-
-        if (initialLocationForSecondaryLookup !== undefined) {
-            // check secondary locations
-            if (traceEnabled) {
-                trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
-            }
-            resolvedFile = loadModuleFromNodeModules(typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState);
-            if (traceEnabled) {
-                if (resolvedFile) {
-                    trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolvedFile, false);
-                }
-                else {
-                    trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
-                }
-            }
-        }
-        else {
-            if (traceEnabled) {
-                trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
-            }
-        }
-        return {
-            resolvedTypeReferenceDirective: resolvedFile
-                ? { primary: false, resolvedFileName: resolvedFile }
-                : undefined,
-            failedLookupLocations
-        };
-    }
-
-    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
-        const traceEnabled = isTraceEnabled(compilerOptions, host);
-        if (traceEnabled) {
-            trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
-        }
-
-        let moduleResolution = compilerOptions.moduleResolution;
-        if (moduleResolution === undefined) {
-            moduleResolution = getEmitModuleKind(compilerOptions) === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic;
-            if (traceEnabled) {
-                trace(host, Diagnostics.Module_resolution_kind_is_not_specified_using_0, ModuleResolutionKind[moduleResolution]);
-            }
-        }
-        else {
-            if (traceEnabled) {
-                trace(host, Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ModuleResolutionKind[moduleResolution]);
-            }
-        }
-
-        let result: ResolvedModuleWithFailedLookupLocations;
-        switch (moduleResolution) {
-            case ModuleResolutionKind.NodeJs:
-                result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host);
-                break;
-            case ModuleResolutionKind.Classic:
-                result = classicNameResolver(moduleName, containingFile, compilerOptions, host);
-                break;
-        }
-
-        if (traceEnabled) {
-            if (result.resolvedModule) {
-                trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
-            }
-            else {
-                trace(host, Diagnostics.Module_name_0_was_not_resolved, moduleName);
-            }
-        }
-
-        return result;
-    }
-
-    /*
-     * Every module resolution kind can has its specific understanding how to load module from a specific path on disk
-     * I.e. for path '/a/b/c':
-     * - Node loader will first to try to check if '/a/b/c' points to a file with some supported extension and if this fails
-     * it will try to load module from directory: directory '/a/b/c' should exist and it should have either 'package.json' with
-     * 'typings' entry or file 'index' with some supported extension
-     * - Classic loader will only try to interpret '/a/b/c' as file.
-     */
-    type ResolutionKindSpecificLoader = (candidate: string, extensions: string[], failedLookupLocations: string[], onlyRecordFailures: boolean, state: ModuleResolutionState) => string;
-
-    /**
-     * Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to
-     * mitigate differences between design time structure of the project and its runtime counterpart so the same import name
-     * can be resolved successfully by TypeScript compiler and runtime module loader.
-     * If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will
-     * fallback to standard resolution routine.
-     *
-     * - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative
-     * names will be resolved relative to baseUrl: i.e. if baseUrl is '/a/b' then candidate location to resolve module name 'c/d' will
-     * be '/a/b/c/d'
-     * - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names
-     * will be resolved based on the content of the module name.
-     * Structure of 'paths' compiler options
-     * 'paths': {
-     *    pattern-1: [...substitutions],
-     *    pattern-2: [...substitutions],
-     *    ...
-     *    pattern-n: [...substitutions]
-     * }
-     * Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against
-     * all patterns in the list. Matching for patterns that don't contain '*' means that module name must be equal to pattern respecting the case.
-     * If pattern contains '*' then to match pattern "<prefix>*<suffix>" module name must start with the <prefix> and end with <suffix>.
-     * <MatchedStar> denotes part of the module name between <prefix> and <suffix>.
-     * If module name can be matches with multiple patterns then pattern with the longest prefix will be picked.
-     * After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module
-     * from the candidate location.
-     * Substitution is a string that can contain zero or one '*'. To get candidate location from substitution we'll pick every
-     * substitution in the list and replace '*' with <MatchedStar> string. If candidate location is not rooted it
-     * will be converted to absolute using baseUrl.
-     * For example:
-     * baseUrl: /a/b/c
-     * "paths": {
-     *     // match all module names
-     *     "*": [
-     *         "*",        // use matched name as is,
-     *                     // <matched name> will be looked as /a/b/c/<matched name>
-     *
-     *         "folder1/*" // substitution will convert matched name to 'folder1/<matched name>',
-     *                     // since it is not rooted then final candidate location will be /a/b/c/folder1/<matched name>
-     *     ],
-     *     // match module names that start with 'components/'
-     *     "components/*": [ "/root/components/*" ] // substitution will convert /components/folder1/<matched name> to '/root/components/folder1/<matched name>',
-     *                                              // it is rooted so it will be final candidate location
-     * }
-     *
-     * 'rootDirs' allows the project to be spreaded across multiple locations and resolve modules with relative names as if
-     * they were in the same location. For example lets say there are two files
-     * '/local/src/content/file1.ts'
-     * '/shared/components/contracts/src/content/protocols/file2.ts'
-     * After bundling content of '/shared/components/contracts/src' will be merged with '/local/src' so
-     * if file1 has the following import 'import {x} from "./protocols/file2"' it will be resolved successfully in runtime.
-     * 'rootDirs' provides the way to tell compiler that in order to get the whole project it should behave as if content of all
-     * root dirs were merged together.
-     * I.e. for the example above 'rootDirs' will have two entries: [ '/local/src', '/shared/components/contracts/src' ].
-     * Compiler will first convert './protocols/file2' into absolute path relative to the location of containing file:
-     * '/local/src/content/protocols/file2' and try to load it - failure.
-     * Then it will search 'rootDirs' looking for a longest matching prefix of this absolute path and if such prefix is found - absolute path will
-     * be converted to a path relative to found rootDir entry './content/protocols/file2' (*). As a last step compiler will check all remaining
-     * entries in 'rootDirs', use them to build absolute path out of (*) and try to resolve module from this location.
-     */
-    function tryLoadModuleUsingOptionalResolutionSettings(moduleName: string, containingDirectory: string, loader: ResolutionKindSpecificLoader,
-        failedLookupLocations: string[], supportedExtensions: string[], state: ModuleResolutionState): string {
-
-        if (moduleHasNonRelativeName(moduleName)) {
-            return tryLoadModuleUsingBaseUrl(moduleName, loader, failedLookupLocations, supportedExtensions, state);
-        }
-        else {
-            return tryLoadModuleUsingRootDirs(moduleName, containingDirectory, loader, failedLookupLocations, supportedExtensions, state);
-        }
-    }
-
-    function tryLoadModuleUsingRootDirs(moduleName: string, containingDirectory: string, loader: ResolutionKindSpecificLoader,
-        failedLookupLocations: string[], supportedExtensions: string[], state: ModuleResolutionState): string {
-
-        if (!state.compilerOptions.rootDirs) {
-            return undefined;
-        }
-
-        if (state.traceEnabled) {
-            trace(state.host, Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
-        }
-
-        const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-
-        let matchedRootDir: string;
-        let matchedNormalizedPrefix: string;
-        for (const rootDir of state.compilerOptions.rootDirs) {
-            // rootDirs are expected to be absolute
-            // in case of tsconfig.json this will happen automatically - compiler will expand relative names
-            // using location of tsconfig.json as base location
-            let normalizedRoot = normalizePath(rootDir);
-            if (!endsWith(normalizedRoot, directorySeparator)) {
-                normalizedRoot += directorySeparator;
-            }
-            const isLongestMatchingPrefix =
-                startsWith(candidate, normalizedRoot) &&
-                (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length);
-
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);
-            }
-
-            if (isLongestMatchingPrefix) {
-                matchedNormalizedPrefix = normalizedRoot;
-                matchedRootDir = rootDir;
-            }
-        }
-        if (matchedNormalizedPrefix) {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
-            }
-            const suffix = candidate.substr(matchedNormalizedPrefix.length);
-
-            // first - try to load from a initial location
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
-            }
-            const resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(containingDirectory, state.host), state);
-            if (resolvedFileName) {
-                return resolvedFileName;
-            }
-
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Trying_other_entries_in_rootDirs);
-            }
-            // then try to resolve using remaining entries in rootDirs
-            for (const rootDir of state.compilerOptions.rootDirs) {
-                if (rootDir === matchedRootDir) {
-                    // skip the initially matched entry
-                    continue;
-                }
-                const candidate = combinePaths(normalizePath(rootDir), suffix);
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate);
-                }
-                const baseDirectory = getDirectoryPath(candidate);
-                const resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(baseDirectory, state.host), state);
-                if (resolvedFileName) {
-                    return resolvedFileName;
-                }
-            }
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Module_resolution_using_rootDirs_has_failed);
-            }
-        }
-        return undefined;
-    }
-
-    function tryLoadModuleUsingBaseUrl(moduleName: string, loader: ResolutionKindSpecificLoader, failedLookupLocations: string[],
-        supportedExtensions: string[], state: ModuleResolutionState): string {
-
-        if (!state.compilerOptions.baseUrl) {
-            return undefined;
-        }
-        if (state.traceEnabled) {
-            trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, state.compilerOptions.baseUrl, moduleName);
-        }
-
-        // string is for exact match
-        let matchedPattern: Pattern | string | undefined = undefined;
-        if (state.compilerOptions.paths) {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
-            }
-            matchedPattern = matchPatternOrExact(getOwnKeys(state.compilerOptions.paths), moduleName);
-        }
-
-        if (matchedPattern) {
-            const matchedStar = typeof matchedPattern === "string" ? undefined : matchedText(matchedPattern, moduleName);
-            const matchedPatternText = typeof matchedPattern === "string" ? matchedPattern : patternText(matchedPattern);
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
-            }
-            for (const subst of state.compilerOptions.paths[matchedPatternText]) {
-                const path = matchedStar ? subst.replace("*", matchedStar) : subst;
-                const candidate = normalizePath(combinePaths(state.compilerOptions.baseUrl, path));
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
-                }
-                const resolvedFileName = loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
-                if (resolvedFileName) {
-                    return resolvedFileName;
-                }
-            }
-            return undefined;
-        }
-        else {
-            const candidate = normalizePath(combinePaths(state.compilerOptions.baseUrl, moduleName));
-
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, state.compilerOptions.baseUrl, candidate);
-            }
-
-            return loader(candidate, supportedExtensions, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
-        }
-    }
-
-    /**
-     * patternStrings contains both pattern strings (containing "*") and regular strings.
-     * Return an exact match if possible, or a pattern match, or undefined.
-     * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
-     */
-    function matchPatternOrExact(patternStrings: string[], candidate: string): string | Pattern | undefined {
-        const patterns: Pattern[] = [];
-        for (const patternString of patternStrings) {
-            const pattern = tryParsePattern(patternString);
-            if (pattern) {
-                patterns.push(pattern);
-            }
-            else if (patternString === candidate) {
-                // pattern was matched as is - no need to search further
-                return patternString;
-            }
-        }
-
-        return findBestPatternMatch(patterns, _ => _, candidate);
-    }
-
-    function patternText({prefix, suffix}: Pattern): string {
-        return `${prefix}*${suffix}`;
-    }
-
-    /**
-     * Given that candidate matches pattern, returns the text matching the '*'.
-     * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar"
-     */
-    function matchedText(pattern: Pattern, candidate: string): string {
-        Debug.assert(isPatternMatch(pattern, candidate));
-        return candidate.substr(pattern.prefix.length, candidate.length - pattern.suffix.length);
-    }
-
-    /** Return the object corresponding to the best pattern to match `candidate`. */
-    /* @internal */
-    export function findBestPatternMatch<T>(values: T[], getPattern: (value: T) => Pattern, candidate: string): T | undefined {
-        let matchedValue: T | undefined = undefined;
-        // use length of prefix as betterness criteria
-        let longestMatchPrefixLength = -1;
-
-        for (const v of values) {
-            const pattern = getPattern(v);
-            if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
-                longestMatchPrefixLength = pattern.prefix.length;
-                matchedValue = v;
-            }
-        }
-
-        return matchedValue;
-    }
-
-    function isPatternMatch({prefix, suffix}: Pattern, candidate: string) {
-        return candidate.length >= prefix.length + suffix.length &&
-               startsWith(candidate, prefix) &&
-               endsWith(candidate, suffix);
-    }
-
-    /* @internal */
-    export function tryParsePattern(pattern: string): Pattern | undefined {
-        // This should be verified outside of here and a proper error thrown.
-        Debug.assert(hasZeroOrOneAsteriskCharacter(pattern));
-        const indexOfStar = pattern.indexOf("*");
-        return indexOfStar === -1 ? undefined : {
-            prefix: pattern.substr(0, indexOfStar),
-            suffix: pattern.substr(indexOfStar + 1)
-        };
-    }
-
-    export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
-        const containingDirectory = getDirectoryPath(containingFile);
-        const supportedExtensions = getSupportedExtensions(compilerOptions);
-        const traceEnabled = isTraceEnabled(compilerOptions, host);
-
-        const failedLookupLocations: string[] = [];
-        const state = { compilerOptions, host, traceEnabled, skipTsx: false };
-        let resolvedFileName = tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, nodeLoadModuleByRelativeName,
-            failedLookupLocations, supportedExtensions, state);
-
-        let isExternalLibraryImport = false;
-        if (!resolvedFileName) {
-            if (moduleHasNonRelativeName(moduleName)) {
-                if (traceEnabled) {
-                    trace(host, Diagnostics.Loading_module_0_from_node_modules_folder, moduleName);
-                }
-                resolvedFileName = loadModuleFromNodeModules(moduleName, containingDirectory, failedLookupLocations, state);
-                isExternalLibraryImport = resolvedFileName !== undefined;
-            }
-            else {
-                const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-                resolvedFileName = nodeLoadModuleByRelativeName(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
-            }
-        }
-
-        if (resolvedFileName && host.realpath) {
-            const originalFileName = resolvedFileName;
-            resolvedFileName = normalizePath(host.realpath(resolvedFileName));
-            if (traceEnabled) {
-                trace(host, Diagnostics.Resolving_real_path_for_0_result_1, originalFileName, resolvedFileName);
-            }
-        }
-
-        return createResolvedModule(resolvedFileName, isExternalLibraryImport, failedLookupLocations);
-    }
-
-    function nodeLoadModuleByRelativeName(candidate: string, supportedExtensions: string[], failedLookupLocations: string[],
-        onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-
-        if (state.traceEnabled) {
-            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
-        }
-
-        const resolvedFileName = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, onlyRecordFailures, state);
-
-        return resolvedFileName || loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, onlyRecordFailures, state);
-    }
-
-    /* @internal */
-    export function directoryProbablyExists(directoryName: string, host: { directoryExists?: (directoryName: string) => boolean }): boolean {
-        // if host does not support 'directoryExists' assume that directory will exist
-        return !host.directoryExists || host.directoryExists(directoryName);
-    }
-
-    /**
-     * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
-     * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations.
-     */
-    function loadModuleFromFile(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
-        // First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts"
-        const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, failedLookupLocation, onlyRecordFailures, state);
-        if (resolvedByAddingExtension) {
-            return resolvedByAddingExtension;
-        }
-
-        // If that didn't work, try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one;
-        // e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts"
-        if (hasJavaScriptFileExtension(candidate)) {
-            const extensionless = removeFileExtension(candidate);
-            if (state.traceEnabled) {
-                const extension = candidate.substring(extensionless.length);
-                trace(state.host, Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
-            }
-            return tryAddingExtensions(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
-        }
-    }
-
-    /** Try to return an existing file that adds one of the `extensions` to `candidate`. */
-    function tryAddingExtensions(candidate: string, extensions: string[], failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
-        if (!onlyRecordFailures) {
-            // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
-            const directory = getDirectoryPath(candidate);
-            if (directory) {
-                onlyRecordFailures = !directoryProbablyExists(directory, state.host);
-            }
-        }
-        return forEach(extensions, ext =>
-            !(state.skipTsx && isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state));
-    }
-
-    /** Return the file if it exists. */
-    function tryFile(fileName: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string | undefined {
-        if (!onlyRecordFailures && state.host.fileExists(fileName)) {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
-            }
-            return fileName;
-        }
-        else {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
-            }
-            failedLookupLocation.push(fileName);
-            return undefined;
-        }
-    }
-
-    function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, state: ModuleResolutionState): string {
-        const packageJsonPath = pathToPackageJson(candidate);
-        const directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, state.host);
-        if (directoryExists && state.host.fileExists(packageJsonPath)) {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.Found_package_json_at_0, packageJsonPath);
-            }
-            const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
-            if (typesFile) {
-                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
-                // The package.json "typings" property must specify the file with extension, so just try that exact filename.
-                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state);
-                if (result) {
-                    return result;
-                }
-            }
-            else {
-                if (state.traceEnabled) {
-                    trace(state.host, Diagnostics.package_json_does_not_have_types_field);
-                }
-            }
-        }
-        else {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_does_not_exist, packageJsonPath);
-            }
-            // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results
-            failedLookupLocation.push(packageJsonPath);
-        }
-
-        return loadModuleFromFile(combinePaths(candidate, "index"), extensions, failedLookupLocation, !directoryExists, state);
-    }
-
-    function pathToPackageJson(directory: string): string {
-        return combinePaths(directory, "package.json");
-    }
-
-    function loadModuleFromNodeModulesFolder(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
-        const nodeModulesFolder = combinePaths(directory, "node_modules");
-        const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
-        const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
-        const supportedExtensions = getSupportedExtensions(state.compilerOptions);
-
-        let result = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, !nodeModulesFolderExists, state);
-        if (result) {
-            return result;
-        }
-        result = loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state);
-        if (result) {
-            return result;
-        }
-    }
-
-    function loadModuleFromNodeModules(moduleName: string, directory: string, failedLookupLocations: string[], state: ModuleResolutionState): string {
-        directory = normalizeSlashes(directory);
-        while (true) {
-            const baseName = getBaseFileName(directory);
-            if (baseName !== "node_modules") {
-                // Try to load source from the package
-                const packageResult = loadModuleFromNodeModulesFolder(moduleName, directory, failedLookupLocations, state);
-                if (packageResult && hasTypeScriptFileExtension(packageResult)) {
-                    // Always prefer a TypeScript (.ts, .tsx, .d.ts) file shipped with the package
-                    return packageResult;
-                }
-                else {
-                    // Else prefer a types package over non-TypeScript results (e.g. JavaScript files)
-                    const typesResult = loadModuleFromNodeModulesFolder(combinePaths("@types", moduleName), directory, failedLookupLocations, state);
-                    if (typesResult || packageResult) {
-                        return typesResult || packageResult;
-                    }
-                }
-            }
-
-            const parentPath = getDirectoryPath(directory);
-            if (parentPath === directory) {
-                break;
-            }
-
-            directory = parentPath;
-        }
-        return undefined;
-    }
-
-    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
-        const traceEnabled = isTraceEnabled(compilerOptions, host);
-        const state = { compilerOptions, host, traceEnabled, skipTsx: !compilerOptions.jsx };
-        const failedLookupLocations: string[] = [];
-        const supportedExtensions = getSupportedExtensions(compilerOptions);
-        let containingDirectory = getDirectoryPath(containingFile);
-
-        const resolvedFileName = tryLoadModuleUsingOptionalResolutionSettings(moduleName, containingDirectory, loadModuleFromFile, failedLookupLocations, supportedExtensions, state);
-        if (resolvedFileName) {
-            return createResolvedModule(resolvedFileName, /*isExternalLibraryImport*/false, failedLookupLocations);
-        }
-
-        let referencedSourceFile: string;
-        if (moduleHasNonRelativeName(moduleName)) {
-            while (true) {
-                const searchName = normalizePath(combinePaths(containingDirectory, moduleName));
-                referencedSourceFile = loadModuleFromFile(searchName, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
-                if (referencedSourceFile) {
-                    break;
-                }
-                const parentPath = getDirectoryPath(containingDirectory);
-                if (parentPath === containingDirectory) {
-                    break;
-                }
-                containingDirectory = parentPath;
-            }
-        }
-        else {
-            const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-            referencedSourceFile = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
-        }
-
-
-        return referencedSourceFile
-            ? { resolvedModule: { resolvedFileName: referencedSourceFile }, failedLookupLocations }
-            : { resolvedModule: undefined, failedLookupLocations };
-    }
-
     interface OutputFingerprint {
         hash: string;
         byteOrderMark: boolean;
@@ -962,6 +206,7 @@ namespace ts {
             readFile: fileName => sys.readFile(fileName),
             trace: (s: string) => sys.write(s + newLine),
             directoryExists: directoryName => sys.directoryExists(directoryName),
+            getEnvironmentVariable: name => sys.getEnvironmentVariable ? sys.getEnvironmentVariable(name) : "",
             getDirectories: (path: string) => sys.getDirectories(path),
             realpath
         };
@@ -1044,44 +289,6 @@ namespace ts {
         return resolutions;
     }
 
-    /**
-      * Given a set of options, returns the set of type directive names
-      *   that should be included for this program automatically.
-      * This list could either come from the config file,
-      *   or from enumerating the types root + initial secondary types lookup location.
-      * More type directives might appear in the program later as a result of loading actual source files;
-      *   this list is only the set of defaults that are implicitly included.
-      */
-    export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[] {
-        // Use explicit type list from tsconfig.json
-        if (options.types) {
-            return options.types;
-        }
-
-        // Walk the primary type lookup locations
-        const result: string[] = [];
-        if (host.directoryExists && host.getDirectories) {
-            const typeRoots = getEffectiveTypeRoots(options, host);
-            if (typeRoots) {
-                for (const root of typeRoots) {
-                    if (host.directoryExists(root)) {
-                        for (const typeDirectivePath of host.getDirectories(root)) {
-                            const normalized = normalizePath(typeDirectivePath);
-                            const packageJsonPath = pathToPackageJson(combinePaths(root, normalized));
-                            // tslint:disable-next-line:no-null-keyword
-                            const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
-                            if (!isNotNeededPackage) {
-                                // Return just the type directive names
-                                result.push(getBaseFileName(normalized));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
     export function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program {
         let program: Program;
         let files: SourceFile[] = [];
@@ -1100,7 +307,7 @@ namespace ts {
         // - This calls resolveModuleNames, and then calls findSourceFile for each resolved module.
         // As all these operations happen - and are nested - within the createProgram call, they close over the below variables.
         // The current resolution depth is tracked by incrementing/decrementing as the depth first search progresses.
-        const maxNodeModulesJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 2;
+        const maxNodeModulesJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
         let currentNodeModulesDepth = 0;
 
         // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track
@@ -1151,7 +358,7 @@ namespace ts {
             // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
             const typeReferences: string[] = getAutomaticTypeDirectiveNames(options, host);
 
-            if (typeReferences) {
+            if (typeReferences.length) {
                 // This containingFilename needs to match with the one used in managed-side
                 const containingFilename = combinePaths(host.getCurrentDirectory(), "__inferred type names__.ts");
                 const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
@@ -1204,7 +411,8 @@ namespace ts {
             getSymbolCount: () => getDiagnosticsProducingTypeChecker().getSymbolCount(),
             getTypeCount: () => getDiagnosticsProducingTypeChecker().getTypeCount(),
             getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
-            getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives
+            getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
+            dropDiagnosticsProducingTypeChecker
         };
 
         verifyCompilerOptions();
@@ -1265,6 +473,7 @@ namespace ts {
                 (oldOptions.configFilePath !== options.configFilePath) ||
                 (oldOptions.baseUrl !== options.baseUrl) ||
                 (oldOptions.maxNodeModuleJsDepth !== options.maxNodeModuleJsDepth) ||
+                !arrayIsEqualTo(oldOptions.lib, options.lib) ||
                 !arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||
                 !arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||
                 !equalOwnProperties(oldOptions.paths, options.paths)) {
@@ -1400,19 +609,23 @@ namespace ts {
             return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ true));
         }
 
+        function dropDiagnosticsProducingTypeChecker() {
+            diagnosticsProducingTypeChecker = undefined;
+        }
+
         function getTypeChecker() {
             return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ false));
         }
 
-        function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult {
-            return runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken));
+        function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult {
+            return runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles));
         }
 
         function isEmitBlocked(emitFileName: string): boolean {
             return hasEmitBlockingDiagnostics.contains(toPath(emitFileName, currentDirectory, getCanonicalFileName));
         }
 
-        function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken): EmitResult {
+        function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult {
             let declarationDiagnostics: Diagnostic[] = [];
 
             if (options.noEmit) {
@@ -1457,7 +670,8 @@ namespace ts {
             const emitResult = emitFiles(
                 emitResolver,
                 getEmitHost(writeFileCallback),
-                sourceFile);
+                sourceFile,
+                emitOnlyDtsFiles);
 
             performance.mark("afterEmit");
             performance.measure("Emit", "beforeEmit", "afterEmit");
@@ -1705,7 +919,7 @@ namespace ts {
                     return false;
                 }
 
-                function checkModifiers(modifiers: ModifiersArray): boolean {
+                function checkModifiers(modifiers: NodeArray<Modifier>): boolean {
                     if (modifiers) {
                         for (const modifier of modifiers) {
                             switch (modifier.kind) {
@@ -1789,6 +1003,17 @@ namespace ts {
             let imports: LiteralExpression[];
             let moduleAugmentations: LiteralExpression[];
 
+            // If we are importing helpers, we need to add a synthetic reference to resolve the
+            // helpers library.
+            if (options.importHelpers
+                && (options.isolatedModules || isExternalModuleFile)
+                && !file.isDeclarationFile) {
+                const externalHelpersModuleReference = <StringLiteral>createNode(SyntaxKind.StringLiteral);
+                externalHelpersModuleReference.text = externalHelpersModuleNameText;
+                externalHelpersModuleReference.parent = file;
+                imports = [externalHelpersModuleReference];
+            }
+
             for (const node of file.statements) {
                 collectModuleReferences(node, /*inAmbientModule*/ false);
                 if (isJavaScriptFile) {
@@ -1822,7 +1047,7 @@ namespace ts {
                         }
                         break;
                     case SyntaxKind.ModuleDeclaration:
-                        if (isAmbientModule(<ModuleDeclaration>node) && (inAmbientModule || node.flags & NodeFlags.Ambient || isDeclarationFile(file))) {
+                        if (isAmbientModule(<ModuleDeclaration>node) && (inAmbientModule || hasModifier(node, ModifierFlags.Ambient) || isDeclarationFile(file))) {
                             const moduleName = <LiteralExpression>(<ModuleDeclaration>node).name;
                             // Ambient module declarations can be interpreted as augmentations for some existing external modules.
                             // This will happen in two cases:
@@ -2086,7 +1311,6 @@ namespace ts {
                 for (let i = 0; i < moduleNames.length; i++) {
                     const resolution = resolutions[i];
                     setResolvedModule(file, moduleNames[i], resolution);
-                    const resolvedPath = resolution ? toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName) : undefined;
 
                     // add file to program only if:
                     // - resolution was successful
@@ -2108,7 +1332,7 @@ namespace ts {
                     }
                     else if (shouldAddFile) {
                         findSourceFile(resolution.resolvedFileName,
-                                resolvedPath,
+                                toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName),
                                 /*isDefaultLib*/ false, /*isReference*/ false,
                                 file,
                                 skipTrivia(file.text, file.imports[i].pos),
@@ -2249,12 +1473,16 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"));
             }
 
+            if (options.noImplicitUseStrict && options.alwaysStrict) {
+                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict"));
+            }
+
             const languageVersion = options.target || ScriptTarget.ES3;
             const outFile = options.outFile || options.out;
 
             const firstNonAmbientExternalModuleSourceFile = forEach(files, f => isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
             if (options.isolatedModules) {
-                if (options.module === ModuleKind.None && languageVersion < ScriptTarget.ES6) {
+                if (options.module === ModuleKind.None && languageVersion < ScriptTarget.ES2015) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher));
                 }
 
@@ -2264,7 +1492,7 @@ namespace ts {
                     programDiagnostics.add(createFileDiagnostic(firstNonExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided));
                 }
             }
-            else if (firstNonAmbientExternalModuleSourceFile && languageVersion < ScriptTarget.ES6 && options.module === ModuleKind.None) {
+            else if (firstNonAmbientExternalModuleSourceFile && languageVersion < ScriptTarget.ES2015 && options.module === ModuleKind.None) {
                 // We cannot use createDiagnosticFromNode because nodes do not have parents yet
                 const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
                 programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
@@ -2305,7 +1533,7 @@ namespace ts {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators"));
             }
 
-            if (options.reactNamespace && !isIdentifier(options.reactNamespace, languageVersion)) {
+            if (options.reactNamespace && !isIdentifierText(options.reactNamespace, languageVersion)) {
                 programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace));
             }
 

src/compiler/scanner.ts

@@ -27,6 +27,7 @@ namespace ts {
         reScanSlashToken(): SyntaxKind;
         reScanTemplateToken(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
+        scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): SyntaxKind;
         scanJsxToken(): SyntaxKind;
         scanJSDocToken(): SyntaxKind;
@@ -439,9 +440,7 @@ namespace ts {
 
       /* @internal */
       export function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean, stopAtComments = false): number {
-          // Using ! with a greater than test is a fast way of testing the following conditions:
-          //  pos === undefined || pos === null || isNaN(pos) || pos < 0;
-          if (!(pos >= 0)) {
+          if (positionIsSynthesized(pos)) {
               return pos;
           }
 
@@ -590,20 +589,34 @@ namespace ts {
     }
 
     /**
-     * Extract comments from text prefixing the token closest following `pos`.
-     * The return value is an array containing a TextRange for each comment.
-     * Single-line comment ranges include the beginning '//' characters but not the ending line break.
-     * Multi - line comment ranges include the beginning '/* and ending '<asterisk>/' characters.
-     * The return value is undefined if no comments were found.
-     * @param trailing
-     * If false, whitespace is skipped until the first line break and comments between that location
-     * and the next token are returned.
-     * If true, comments occurring between the given position and the next line break are returned.
+     * Invokes a callback for each comment range following the provided position.
+     *
+     * Single-line comment ranges include the leading double-slash characters but not the ending
+     * line break. Multi-line comment ranges include the leading slash-asterisk and trailing
+     * asterisk-slash characters.
+     *
+     * @param reduce If true, accumulates the result of calling the callback in a fashion similar
+     *      to reduceLeft. If false, iteration stops when the callback returns a truthy value.
+     * @param text The source text to scan.
+     * @param pos The position at which to start scanning.
+     * @param trailing If false, whitespace is skipped until the first line break and comments
+     *      between that location and the next token are returned. If true, comments occurring
+     *      between the given position and the next line break are returned.
+     * @param cb The callback to execute as each comment range is encountered.
+     * @param state A state value to pass to each iteration of the callback.
+     * @param initial An initial value to pass when accumulating results (when "reduce" is true).
+     * @returns If "reduce" is true, the accumulated value. If "reduce" is false, the first truthy
+     *      return value of the callback.
      */
-    function getCommentRanges(text: string, pos: number, trailing: boolean): CommentRange[] {
-        let result: CommentRange[];
+    function iterateCommentRanges<T, U>(reduce: boolean, text: string, pos: number, trailing: boolean, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial?: U): U {
+        let pendingPos: number;
+        let pendingEnd: number;
+        let pendingKind: SyntaxKind;
+        let pendingHasTrailingNewLine: boolean;
+        let hasPendingCommentRange = false;
         let collecting = trailing || pos === 0;
-        while (pos < text.length) {
+        let accumulator = initial;
+        scan: while (pos >= 0 && pos < text.length) {
             const ch = text.charCodeAt(pos);
             switch (ch) {
                 case CharacterCodes.carriageReturn:
@@ -613,12 +626,14 @@ namespace ts {
                 case CharacterCodes.lineFeed:
                     pos++;
                     if (trailing) {
-                        return result;
+                        break scan;
                     }
+
                     collecting = true;
-                    if (result && result.length) {
-                        lastOrUndefined(result).hasTrailingNewLine = true;
+                    if (hasPendingCommentRange) {
+                        pendingHasTrailingNewLine = true;
                     }
+
                     continue;
                 case CharacterCodes.tab:
                 case CharacterCodes.verticalTab:
@@ -651,38 +666,78 @@ namespace ts {
                                 pos++;
                             }
                         }
+
                         if (collecting) {
-                            if (!result) {
-                                result = [];
+                            if (hasPendingCommentRange) {
+                                accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
+                                if (!reduce && accumulator) {
+                                    // If we are not reducing and we have a truthy result, return it.
+                                    return accumulator;
+                                }
+
+                                hasPendingCommentRange = false;
                             }
 
-                            result.push({ pos: startPos, end: pos, hasTrailingNewLine, kind });
+                            pendingPos = startPos;
+                            pendingEnd = pos;
+                            pendingKind = kind;
+                            pendingHasTrailingNewLine = hasTrailingNewLine;
+                            hasPendingCommentRange = true;
                         }
+
                         continue;
                     }
-                    break;
+                    break scan;
                 default:
                     if (ch > CharacterCodes.maxAsciiCharacter && (isWhiteSpace(ch))) {
-                        if (result && result.length && isLineBreak(ch)) {
-                            lastOrUndefined(result).hasTrailingNewLine = true;
+                        if (hasPendingCommentRange && isLineBreak(ch)) {
+                            pendingHasTrailingNewLine = true;
                         }
                         pos++;
                         continue;
                     }
-                    break;
+                    break scan;
             }
-            return result;
         }
 
-        return result;
+        if (hasPendingCommentRange) {
+            accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
+        }
+
+        return accumulator;
+    }
+
+    export function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
+        return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ false, cb, state);
+    }
+
+    export function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T) {
+        return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ true, cb, state);
+    }
+
+    export function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U) {
+        return iterateCommentRanges(/*reduce*/ true, text, pos, /*trailing*/ false, cb, state, initial);
+    }
+
+    export function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U) {
+        return iterateCommentRanges(/*reduce*/ true, text, pos, /*trailing*/ true, cb, state, initial);
+    }
+
+    function appendCommentRange(pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: any, comments: CommentRange[]) {
+        if (!comments) {
+            comments = [];
+        }
+
+        comments.push({ pos, end, hasTrailingNewLine, kind });
+        return comments;
     }
 
     export function getLeadingCommentRanges(text: string, pos: number): CommentRange[] {
-        return getCommentRanges(text, pos, /*trailing*/ false);
+        return reduceEachLeadingCommentRange(text, pos, appendCommentRange, undefined, undefined);
     }
 
     export function getTrailingCommentRanges(text: string, pos: number): CommentRange[] {
-        return getCommentRanges(text, pos, /*trailing*/ true);
+        return reduceEachTrailingCommentRange(text, pos, appendCommentRange, undefined, undefined);
     }
 
     /** Optionally, get the shebang */
@@ -705,7 +760,7 @@ namespace ts {
     }
 
     /* @internal */
-    export function isIdentifier(name: string, languageVersion: ScriptTarget): boolean {
+    export function isIdentifierText(name: string, languageVersion: ScriptTarget): boolean {
         if (!isIdentifierStart(name.charCodeAt(0), languageVersion)) {
             return false;
         }
@@ -763,6 +818,7 @@ namespace ts {
             reScanSlashToken,
             reScanTemplateToken,
             scanJsxIdentifier,
+            scanJsxAttributeValue,
             reScanJsxToken,
             scanJsxToken,
             scanJSDocToken,
@@ -857,7 +913,7 @@ namespace ts {
             return value;
         }
 
-        function scanString(): string {
+        function scanString(allowEscapes = true): string {
             const quote = text.charCodeAt(pos);
             pos++;
             let result = "";
@@ -875,7 +931,7 @@ namespace ts {
                     pos++;
                     break;
                 }
-                if (ch === CharacterCodes.backslash) {
+                if (ch === CharacterCodes.backslash && allowEscapes) {
                     result += text.substring(start, pos);
                     result += scanEscapeSequence();
                     start = pos;
@@ -1134,7 +1190,7 @@ namespace ts {
         }
 
         function scanBinaryOrOctalDigits(base: number): number {
-            Debug.assert(base !== 2 || base !== 8, "Expected either base 2 or base 8");
+            Debug.assert(base === 2 || base === 8, "Expected either base 2 or base 8");
 
             let value = 0;
             // For counting number of digits; Valid binaryIntegerLiteral must have at least one binary digit following B or b.
@@ -1683,46 +1739,66 @@ namespace ts {
             return token;
         }
 
+        function scanJsxAttributeValue(): SyntaxKind {
+            startPos = pos;
+
+            switch (text.charCodeAt(pos)) {
+                case CharacterCodes.doubleQuote:
+                case CharacterCodes.singleQuote:
+                    tokenValue = scanString(/*allowEscapes*/ false);
+                    return token = SyntaxKind.StringLiteral;
+                default:
+                    // If this scans anything other than `{`, it's a parse error.
+                    return scan();
+            }
+        }
+
         function scanJSDocToken(): SyntaxKind {
             if (pos >= end) {
                 return token = SyntaxKind.EndOfFileToken;
             }
 
             startPos = pos;
-
-            // Eat leading whitespace
-            let ch = text.charCodeAt(pos);
-            while (pos < end) {
-                ch = text.charCodeAt(pos);
-                if (isWhiteSpaceSingleLine(ch)) {
-                    pos++;
-                }
-                else {
-                    break;
-                }
-            }
             tokenPos = pos;
 
+            const ch = text.charCodeAt(pos);
             switch (ch) {
+                case CharacterCodes.tab:
+                case CharacterCodes.verticalTab:
+                case CharacterCodes.formFeed:
+                case CharacterCodes.space:
+                    while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
+                        pos++;
+                    }
+                    return token = SyntaxKind.WhitespaceTrivia;
                 case CharacterCodes.at:
-                    return pos += 1, token = SyntaxKind.AtToken;
+                    pos++;
+                    return token = SyntaxKind.AtToken;
                 case CharacterCodes.lineFeed:
                 case CharacterCodes.carriageReturn:
-                    return pos += 1, token = SyntaxKind.NewLineTrivia;
+                    pos++;
+                    return token = SyntaxKind.NewLineTrivia;
                 case CharacterCodes.asterisk:
-                    return pos += 1, token = SyntaxKind.AsteriskToken;
+                    pos++;
+                    return token = SyntaxKind.AsteriskToken;
                 case CharacterCodes.openBrace:
-                    return pos += 1, token = SyntaxKind.OpenBraceToken;
+                    pos++;
+                    return token = SyntaxKind.OpenBraceToken;
                 case CharacterCodes.closeBrace:
-                    return pos += 1, token = SyntaxKind.CloseBraceToken;
+                    pos++;
+                    return token = SyntaxKind.CloseBraceToken;
                 case CharacterCodes.openBracket:
-                    return pos += 1, token = SyntaxKind.OpenBracketToken;
+                    pos++;
+                    return token = SyntaxKind.OpenBracketToken;
                 case CharacterCodes.closeBracket:
-                    return pos += 1, token = SyntaxKind.CloseBracketToken;
+                    pos++;
+                    return token = SyntaxKind.CloseBracketToken;
                 case CharacterCodes.equals:
-                    return pos += 1, token = SyntaxKind.EqualsToken;
+                    pos++;
+                    return token = SyntaxKind.EqualsToken;
                 case CharacterCodes.comma:
-                    return pos += 1, token = SyntaxKind.CommaToken;
+                    pos++;
+                    return token = SyntaxKind.CommaToken;
             }
 
             if (isIdentifierStart(ch, ScriptTarget.Latest)) {

src/compiler/sourcemap.ts

@@ -3,19 +3,73 @@
 /* @internal */
 namespace ts {
     export interface SourceMapWriter {
-        getSourceMapData(): SourceMapData;
-        setSourceFile(sourceFile: SourceFile): void;
-        emitPos(pos: number): void;
-        emitStart(range: TextRange): void;
-        emitEnd(range: TextRange, stopOverridingSpan?: boolean): void;
-        changeEmitSourcePos(): void;
-        getText(): string;
-        getSourceMappingURL(): string;
+        /**
+         * Initialize the SourceMapWriter for a new output file.
+         *
+         * @param filePath The path to the generated output file.
+         * @param sourceMapFilePath The path to the output source map file.
+         * @param sourceFiles The input source files for the program.
+         * @param isBundledEmit A value indicating whether the generated output file is a bundle.
+         */
         initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean): void;
+
+        /**
+         * Reset the SourceMapWriter to an empty state.
+         */
         reset(): void;
+
+        /**
+         * Set the current source file.
+         *
+         * @param sourceFile The source file.
+         */
+        setSourceFile(sourceFile: SourceFile): void;
+
+        /**
+         * Emits a mapping.
+         *
+         * If the position is synthetic (undefined or a negative value), no mapping will be
+         * created.
+         *
+         * @param pos The position.
+         */
+        emitPos(pos: number): void;
+
+        /**
+         * Emits a node with possible leading and trailing source maps.
+         *
+         * @param emitContext The current emit context
+         * @param node The node to emit.
+         * @param emitCallback The callback used to emit the node.
+         */
+        emitNodeWithSourceMap(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+
+        /**
+         * Emits a token of a node node with possible leading and trailing source maps.
+         *
+         * @param node The node containing the token.
+         * @param token The token to emit.
+         * @param tokenStartPos The start pos of the token.
+         * @param emitCallback The callback used to emit the token.
+         */
+        emitTokenWithSourceMap(node: Node, token: SyntaxKind, tokenStartPos: number, emitCallback: (token: SyntaxKind, tokenStartPos: number) => number): number;
+
+        /**
+         * Gets the text for the source map.
+         */
+        getText(): string;
+
+        /**
+         * Gets the SourceMappingURL for the source map.
+         */
+        getSourceMappingURL(): string;
+
+        /**
+         * Gets test data for source maps.
+         */
+        getSourceMapData(): SourceMapData;
     }
 
-    let nullSourceMapWriter: SourceMapWriter;
     // Used for initialize lastEncodedSourceMapSpan and reset lastEncodedSourceMapSpan when updateLastEncodedAndRecordedSpans
     const defaultLastEncodedSourceMapSpan: SourceMapSpan = {
         emittedLine: 1,
@@ -25,32 +79,12 @@ namespace ts {
         sourceIndex: 0
     };
 
-    export function getNullSourceMapWriter(): SourceMapWriter {
-        if (nullSourceMapWriter === undefined) {
-            nullSourceMapWriter = {
-                getSourceMapData(): SourceMapData { return undefined; },
-                setSourceFile(sourceFile: SourceFile): void { },
-                emitStart(range: TextRange): void { },
-                emitEnd(range: TextRange, stopOverridingSpan?: boolean): void { },
-                emitPos(pos: number): void { },
-                changeEmitSourcePos(): void { },
-                getText(): string { return undefined; },
-                getSourceMappingURL(): string { return undefined; },
-                initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean): void { },
-                reset(): void { },
-            };
-        }
-
-        return nullSourceMapWriter;
-    }
-
     export function createSourceMapWriter(host: EmitHost, writer: EmitTextWriter): SourceMapWriter {
         const compilerOptions = host.getCompilerOptions();
         const extendedDiagnostics = compilerOptions.extendedDiagnostics;
         let currentSourceFile: SourceFile;
+        let currentSourceText: string;
         let sourceMapDir: string; // The directory in which sourcemap will be
-        let stopOverridingSpan = false;
-        let modifyLastSourcePos = false;
 
         // Current source map file and its index in the sources list
         let sourceMapSourceIndex: number;
@@ -62,26 +96,39 @@ namespace ts {
 
         // Source map data
         let sourceMapData: SourceMapData;
+        let disabled: boolean = !(compilerOptions.sourceMap || compilerOptions.inlineSourceMap);
 
         return {
+            initialize,
+            reset,
             getSourceMapData: () => sourceMapData,
             setSourceFile,
             emitPos,
-            emitStart,
-            emitEnd,
-            changeEmitSourcePos,
+            emitNodeWithSourceMap,
+            emitTokenWithSourceMap,
             getText,
             getSourceMappingURL,
-            initialize,
-            reset,
         };
 
+        /**
+         * Initialize the SourceMapWriter for a new output file.
+         *
+         * @param filePath The path to the generated output file.
+         * @param sourceMapFilePath The path to the output source map file.
+         * @param sourceFiles The input source files for the program.
+         * @param isBundledEmit A value indicating whether the generated output file is a bundle.
+         */
         function initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean) {
+            if (disabled) {
+                return;
+            }
+
             if (sourceMapData) {
                 reset();
             }
 
             currentSourceFile = undefined;
+            currentSourceText = undefined;
 
             // Current source map file and its index in the sources list
             sourceMapSourceIndex = -1;
@@ -140,7 +187,14 @@ namespace ts {
             }
         }
 
+        /**
+         * Reset the SourceMapWriter to an empty state.
+         */
         function reset() {
+            if (disabled) {
+                return;
+            }
+
             currentSourceFile = undefined;
             sourceMapDir = undefined;
             sourceMapSourceIndex = undefined;
@@ -150,47 +204,6 @@ namespace ts {
             sourceMapData = undefined;
         }
 
-        function updateLastEncodedAndRecordedSpans() {
-            if (modifyLastSourcePos) {
-                // Reset the source pos
-                modifyLastSourcePos = false;
-
-                // Change Last recorded Map with last encoded emit line and character
-                lastRecordedSourceMapSpan.emittedLine = lastEncodedSourceMapSpan.emittedLine;
-                lastRecordedSourceMapSpan.emittedColumn = lastEncodedSourceMapSpan.emittedColumn;
-
-                // Pop sourceMapDecodedMappings to remove last entry
-                sourceMapData.sourceMapDecodedMappings.pop();
-
-                // Point the lastEncodedSourceMapSpace to the previous encoded sourceMapSpan
-                // If the list is empty which indicates that we are at the beginning of the file,
-                // we have to reset it to default value (same value when we first initialize sourceMapWriter)
-                lastEncodedSourceMapSpan = sourceMapData.sourceMapDecodedMappings.length ?
-                    sourceMapData.sourceMapDecodedMappings[sourceMapData.sourceMapDecodedMappings.length - 1] :
-                    defaultLastEncodedSourceMapSpan;
-
-                // TODO: Update lastEncodedNameIndex
-                // Since we dont support this any more, lets not worry about it right now.
-                // When we start supporting nameIndex, we will get back to this
-
-                // Change the encoded source map
-                const sourceMapMappings = sourceMapData.sourceMapMappings;
-                let lenthToSet = sourceMapMappings.length - 1;
-                for (; lenthToSet >= 0; lenthToSet--) {
-                    const currentChar = sourceMapMappings.charAt(lenthToSet);
-                    if (currentChar === ",") {
-                        // Separator for the entry found
-                        break;
-                    }
-                    if (currentChar === ";" && lenthToSet !== 0 && sourceMapMappings.charAt(lenthToSet - 1) !== ";") {
-                        // Last line separator found
-                        break;
-                    }
-                }
-                sourceMapData.sourceMapMappings = sourceMapMappings.substr(0, Math.max(0, lenthToSet));
-            }
-        }
-
         // Encoding for sourcemap span
         function encodeLastRecordedSourceMapSpan() {
             if (!lastRecordedSourceMapSpan || lastRecordedSourceMapSpan === lastEncodedSourceMapSpan) {
@@ -236,8 +249,16 @@ namespace ts {
             sourceMapData.sourceMapDecodedMappings.push(lastEncodedSourceMapSpan);
         }
 
+        /**
+         * Emits a mapping.
+         *
+         * If the position is synthetic (undefined or a negative value), no mapping will be
+         * created.
+         *
+         * @param pos The position.
+         */
         function emitPos(pos: number) {
-            if (pos === -1) {
+            if (disabled || positionIsSynthesized(pos)) {
                 return;
             }
 
@@ -273,45 +294,103 @@ namespace ts {
                     sourceColumn: sourceLinePos.character,
                     sourceIndex: sourceMapSourceIndex
                 };
-
-                stopOverridingSpan = false;
             }
-            else if (!stopOverridingSpan) {
+            else {
                 // Take the new pos instead since there is no change in emittedLine and column since last location
                 lastRecordedSourceMapSpan.sourceLine = sourceLinePos.line;
                 lastRecordedSourceMapSpan.sourceColumn = sourceLinePos.character;
                 lastRecordedSourceMapSpan.sourceIndex = sourceMapSourceIndex;
             }
 
-            updateLastEncodedAndRecordedSpans();
-
             if (extendedDiagnostics) {
                 performance.mark("afterSourcemap");
                 performance.measure("Source Map", "beforeSourcemap", "afterSourcemap");
             }
         }
 
-        function getStartPos(range: TextRange) {
-            const rangeHasDecorators = !!(range as Node).decorators;
-            return range.pos !== -1 ? skipTrivia(currentSourceFile.text, rangeHasDecorators ? (range as Node).decorators.end : range.pos) : -1;
+        /**
+         * Emits a node with possible leading and trailing source maps.
+         *
+         * @param node The node to emit.
+         * @param emitCallback The callback used to emit the node.
+         */
+        function emitNodeWithSourceMap(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+            if (disabled) {
+                return emitCallback(emitContext, node);
+            }
+
+            if (node) {
+                const emitNode = node.emitNode;
+                const emitFlags = emitNode && emitNode.flags;
+                const { pos, end } = emitNode && emitNode.sourceMapRange || node;
+
+                if (node.kind !== SyntaxKind.NotEmittedStatement
+                    && (emitFlags & EmitFlags.NoLeadingSourceMap) === 0
+                    && pos >= 0) {
+                    emitPos(skipTrivia(currentSourceText, pos));
+                }
+
+                if (emitFlags & EmitFlags.NoNestedSourceMaps) {
+                    disabled = true;
+                    emitCallback(emitContext, node);
+                    disabled = false;
+                }
+                else {
+                    emitCallback(emitContext, node);
+                }
+
+                if (node.kind !== SyntaxKind.NotEmittedStatement
+                    && (emitFlags & EmitFlags.NoTrailingSourceMap) === 0
+                    && end >= 0) {
+                    emitPos(end);
+                }
+            }
         }
 
-        function emitStart(range: TextRange) {
-            emitPos(getStartPos(range));
-        }
-
-        function emitEnd(range: TextRange, stopOverridingEnd?: boolean) {
-            emitPos(range.end);
-            stopOverridingSpan = stopOverridingEnd;
-        }
-
-        function changeEmitSourcePos() {
-            Debug.assert(!modifyLastSourcePos);
-            modifyLastSourcePos = true;
+        /**
+         * Emits a token of a node with possible leading and trailing source maps.
+         *
+         * @param node The node containing the token.
+         * @param token The token to emit.
+         * @param tokenStartPos The start pos of the token.
+         * @param emitCallback The callback used to emit the token.
+         */
+        function emitTokenWithSourceMap(node: Node, token: SyntaxKind, tokenPos: number, emitCallback: (token: SyntaxKind, tokenStartPos: number) => number) {
+            if (disabled) {
+                return emitCallback(token, tokenPos);
+            }
+
+            const emitNode = node && node.emitNode;
+            const emitFlags = emitNode && emitNode.flags;
+            const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
+
+            tokenPos = skipTrivia(currentSourceText, range ? range.pos : tokenPos);
+            if ((emitFlags & EmitFlags.NoTokenLeadingSourceMaps) === 0 && tokenPos >= 0) {
+                emitPos(tokenPos);
+            }
+
+            tokenPos = emitCallback(token, tokenPos);
+
+            if (range) tokenPos = range.end;
+            if ((emitFlags & EmitFlags.NoTokenTrailingSourceMaps) === 0 && tokenPos >= 0) {
+                emitPos(tokenPos);
+            }
+
+            return tokenPos;
         }
 
+        /**
+         * Set the current source file.
+         *
+         * @param sourceFile The source file.
+         */
         function setSourceFile(sourceFile: SourceFile) {
+            if (disabled) {
+                return;
+            }
+
             currentSourceFile = sourceFile;
+            currentSourceText = currentSourceFile.text;
 
             // Add the file to tsFilePaths
             // If sourceroot option: Use the relative path corresponding to the common directory path
@@ -330,15 +409,22 @@ namespace ts {
                 sourceMapData.sourceMapSources.push(source);
 
                 // The one that can be used from program to get the actual source file
-                sourceMapData.inputSourceFileNames.push(sourceFile.fileName);
+                sourceMapData.inputSourceFileNames.push(currentSourceFile.fileName);
 
                 if (compilerOptions.inlineSources) {
-                    sourceMapData.sourceMapSourcesContent.push(sourceFile.text);
+                    sourceMapData.sourceMapSourcesContent.push(currentSourceFile.text);
                 }
             }
         }
 
+        /**
+         * Gets the text for the source map.
+         */
         function getText() {
+            if (disabled) {
+                return;
+            }
+
             encodeLastRecordedSourceMapSpan();
 
             return stringify({
@@ -352,7 +438,14 @@ namespace ts {
             });
         }
 
+        /**
+         * Gets the SourceMappingURL for the source map.
+         */
         function getSourceMappingURL() {
+            if (disabled) {
+                return;
+            }
+
             if (compilerOptions.inlineSourceMap) {
                 // Encode the sourceMap into the sourceMap url
                 const base64SourceMapText = convertToBase64(getText());

src/compiler/sys.ts

@@ -32,6 +32,8 @@ namespace ts {
         getMemoryUsage?(): number;
         exit(exitCode?: number): void;
         realpath?(path: string): string;
+        /*@internal*/ getEnvironmentVariable(name: string): string;
+        /*@internal*/ tryEnableSourceMapsForHost?(): void;
     }
 
     export interface FileWatcher {
@@ -78,9 +80,10 @@ namespace ts {
         watchFile?(path: string, callback: FileWatcherCallback): FileWatcher;
         watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher;
         realpath(path: string): string;
+        getEnvironmentVariable?(name: string): string;
     };
 
-    export var sys: System = (function() {
+    export let sys: System = (function() {
 
         function getWScriptSystem(): System {
 
@@ -212,6 +215,9 @@ namespace ts {
                     return shell.CurrentDirectory;
                 },
                 getDirectories,
+                getEnvironmentVariable(name: string) {
+                    return new ActiveXObject("WScript.Shell").ExpandEnvironmentStrings(`%${name}%`);
+                },
                 readDirectory,
                 exit(exitCode?: number): void {
                     try {
@@ -267,7 +273,7 @@ namespace ts {
                 }
 
                 function addFileWatcherCallback(filePath: string, callback: FileWatcherCallback): void {
-                    (fileWatcherCallbacks[filePath] || (fileWatcherCallbacks[filePath] = [])).push(callback);
+                    multiMapAdd(fileWatcherCallbacks, filePath, callback);
                 }
 
                 function addFile(fileName: string, callback: FileWatcherCallback): WatchedFile {
@@ -283,16 +289,7 @@ namespace ts {
                 }
 
                 function removeFileWatcherCallback(filePath: string, callback: FileWatcherCallback) {
-                    const callbacks = fileWatcherCallbacks[filePath];
-                    if (callbacks) {
-                        const newCallbacks = copyListRemovingItem(callback, callbacks);
-                        if (newCallbacks.length === 0) {
-                            delete fileWatcherCallbacks[filePath];
-                        }
-                        else {
-                            fileWatcherCallbacks[filePath] = newCallbacks;
-                        }
-                    }
+                    multiMapRemove(fileWatcherCallbacks, filePath, callback);
                 }
 
                 function fileEventHandler(eventName: string, relativeFileName: string, baseDirPath: string) {
@@ -314,9 +311,18 @@ namespace ts {
                 return parseInt(process.version.charAt(1)) >= 4;
             }
 
+            function isFileSystemCaseSensitive(): boolean {
+                // win32\win64 are case insensitive platforms
+                if (platform === "win32" || platform === "win64") {
+                    return false;
+                }
+                // convert current file name to upper case / lower case and check if file exists
+                // (guards against cases when name is already all uppercase or lowercase)
+                return !fileExists(__filename.toUpperCase()) || !fileExists(__filename.toLowerCase());
+            }
+
             const platform: string = _os.platform();
-            // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
-            const useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";
+            const useCaseSensitiveFileNames = isFileSystemCaseSensitive();
 
             function readFile(fileName: string, encoding?: string): string {
                 if (!fileExists(fileName)) {
@@ -432,7 +438,7 @@ namespace ts {
             }
 
             function getDirectories(path: string): string[] {
-                return filter<string>(_fs.readdirSync(path), p => fileSystemEntryExists(combinePaths(path, p), FileSystemEntryKind.Directory));
+                return filter<string>(_fs.readdirSync(path), dir => fileSystemEntryExists(combinePaths(path, dir), FileSystemEntryKind.Directory));
             }
 
             const nodeSystem: System = {
@@ -470,6 +476,10 @@ namespace ts {
                     // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows
                     // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
                     let options: any;
+                    if (!directoryExists(directoryName)) {
+                        return;
+                    }
+
                     if (isNode4OrLater() && (process.platform === "win32" || process.platform === "darwin")) {
                         options = { persistent: true, recursive: !!recursive };
                     }
@@ -508,6 +518,9 @@ namespace ts {
                     return process.cwd();
                 },
                 getDirectories,
+                getEnvironmentVariable(name: string) {
+                    return process.env[name] || "";
+                },
                 readDirectory,
                 getModifiedTime(path) {
                     try {
@@ -543,6 +556,14 @@ namespace ts {
                 },
                 realpath(path: string): string {
                     return _fs.realpathSync(path);
+                },
+                tryEnableSourceMapsForHost() {
+                    try {
+                        require("source-map-support").install();
+                    }
+                    catch (e) {
+                        // Could not enable source maps.
+                    }
                 }
             };
             return nodeSystem;
@@ -574,6 +595,7 @@ namespace ts {
                 getExecutingFilePath: () => ChakraHost.executingFile,
                 getCurrentDirectory: () => ChakraHost.currentDirectory,
                 getDirectories: ChakraHost.getDirectories,
+                getEnvironmentVariable: ChakraHost.getEnvironmentVariable || ((name: string) => ""),
                 readDirectory: (path: string, extensions?: string[], excludes?: string[], includes?: string[]) => {
                     const pattern = getFileMatcherPatterns(path, extensions, excludes, includes, !!ChakraHost.useCaseSensitiveFileNames, ChakraHost.currentDirectory);
                     return ChakraHost.readDirectory(path, extensions, pattern.basePaths, pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern);
@@ -583,19 +605,46 @@ namespace ts {
             };
         }
 
+        function recursiveCreateDirectory(directoryPath: string, sys: System) {
+            const basePath = getDirectoryPath(directoryPath);
+            const shouldCreateParent = directoryPath !== basePath && !sys.directoryExists(basePath);
+            if (shouldCreateParent) {
+                recursiveCreateDirectory(basePath, sys);
+            }
+            if (shouldCreateParent || !sys.directoryExists(directoryPath)) {
+                sys.createDirectory(directoryPath);
+            }
+        }
+
+        let sys: System;
         if (typeof ChakraHost !== "undefined") {
-            return getChakraSystem();
+            sys = getChakraSystem();
         }
         else if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
-            return getWScriptSystem();
+            sys = getWScriptSystem();
         }
         else if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof require !== "undefined") {
             // process and process.nextTick checks if current environment is node-like
             // process.browser check excludes webpack and browserify
-            return getNodeSystem();
+            sys = getNodeSystem();
         }
-        else {
-            return undefined; // Unsupported host
+        if (sys) {
+            // patch writefile to create folder before writing the file
+            const originalWriteFile = sys.writeFile;
+            sys.writeFile = function(path, data, writeBom) {
+                const directoryPath = getDirectoryPath(normalizeSlashes(path));
+                if (directoryPath && !sys.directoryExists(directoryPath)) {
+                    recursiveCreateDirectory(directoryPath, sys);
+                }
+                originalWriteFile.call(sys, path, data, writeBom);
+            };
         }
+        return sys;
     })();
+
+    if (sys && sys.getEnvironmentVariable) {
+        Debug.currentAssertionLevel = /^development$/i.test(sys.getEnvironmentVariable("NODE_ENV"))
+            ? AssertionLevel.Normal
+            : AssertionLevel.None;
+    }
 }

src/compiler/transformer.ts

@@ -0,0 +1,349 @@
+/// <reference path="visitor.ts" />
+/// <reference path="transformers/ts.ts" />
+/// <reference path="transformers/jsx.ts" />
+/// <reference path="transformers/es2017.ts" />
+/// <reference path="transformers/es2016.ts" />
+/// <reference path="transformers/es2015.ts" />
+/// <reference path="transformers/generators.ts" />
+/// <reference path="transformers/module/module.ts" />
+/// <reference path="transformers/module/system.ts" />
+/// <reference path="transformers/module/es2015.ts" />
+
+/* @internal */
+namespace ts {
+    const moduleTransformerMap = createMap<Transformer>({
+        [ModuleKind.ES2015]: transformES2015Module,
+        [ModuleKind.System]: transformSystemModule,
+        [ModuleKind.AMD]: transformModule,
+        [ModuleKind.CommonJS]: transformModule,
+        [ModuleKind.UMD]: transformModule,
+        [ModuleKind.None]: transformModule,
+    });
+
+    const enum SyntaxKindFeatureFlags {
+        Substitution = 1 << 0,
+        EmitNotifications = 1 << 1,
+    }
+
+    export interface TransformationResult {
+        /**
+         * Gets the transformed source files.
+         */
+        transformed: SourceFile[];
+
+        /**
+         * Emits the substitute for a node, if one is available; otherwise, emits the node.
+         *
+         * @param emitContext The current emit context.
+         * @param node The node to substitute.
+         * @param emitCallback A callback used to emit the node or its substitute.
+         */
+        emitNodeWithSubstitution(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+
+        /**
+         * Emits a node with possible notification.
+         *
+         * @param emitContext The current emit context.
+         * @param node The node to emit.
+         * @param emitCallback A callback used to emit the node.
+         */
+        emitNodeWithNotification(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void;
+    }
+
+    export interface TransformationContext extends LexicalEnvironment {
+        getCompilerOptions(): CompilerOptions;
+        getEmitResolver(): EmitResolver;
+        getEmitHost(): EmitHost;
+
+        /**
+         * Hoists a function declaration to the containing scope.
+         */
+        hoistFunctionDeclaration(node: FunctionDeclaration): void;
+
+        /**
+         * Hoists a variable declaration to the containing scope.
+         */
+        hoistVariableDeclaration(node: Identifier): void;
+
+        /**
+         * Enables expression substitutions in the pretty printer for the provided SyntaxKind.
+         */
+        enableSubstitution(kind: SyntaxKind): void;
+
+        /**
+         * Determines whether expression substitutions are enabled for the provided node.
+         */
+        isSubstitutionEnabled(node: Node): boolean;
+
+        /**
+         * Hook used by transformers to substitute expressions just before they
+         * are emitted by the pretty printer.
+         */
+        onSubstituteNode?: (emitContext: EmitContext, node: Node) => Node;
+
+        /**
+         * Enables before/after emit notifications in the pretty printer for the provided
+         * SyntaxKind.
+         */
+        enableEmitNotification(kind: SyntaxKind): void;
+
+        /**
+         * Determines whether before/after emit notifications should be raised in the pretty
+         * printer when it emits a node.
+         */
+        isEmitNotificationEnabled(node: Node): boolean;
+
+        /**
+         * Hook used to allow transformers to capture state before or after
+         * the printer emits a node.
+         */
+        onEmitNode?: (emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) => void;
+    }
+
+    /* @internal */
+    export type Transformer = (context: TransformationContext) => (node: SourceFile) => SourceFile;
+
+    export function getTransformers(compilerOptions: CompilerOptions) {
+        const jsx = compilerOptions.jsx;
+        const languageVersion = getEmitScriptTarget(compilerOptions);
+        const moduleKind = getEmitModuleKind(compilerOptions);
+        const transformers: Transformer[] = [];
+
+        transformers.push(transformTypeScript);
+        transformers.push(moduleTransformerMap[moduleKind] || moduleTransformerMap[ModuleKind.None]);
+
+        if (jsx === JsxEmit.React) {
+            transformers.push(transformJsx);
+        }
+
+        if (languageVersion < ScriptTarget.ES2017) {
+            transformers.push(transformES2017);
+        }
+
+        if (languageVersion < ScriptTarget.ES2016) {
+            transformers.push(transformES2016);
+        }
+
+        if (languageVersion < ScriptTarget.ES2015) {
+            transformers.push(transformES2015);
+            transformers.push(transformGenerators);
+        }
+
+        return transformers;
+    }
+
+    /**
+     * Transforms an array of SourceFiles by passing them through each transformer.
+     *
+     * @param resolver The emit resolver provided by the checker.
+     * @param host The emit host.
+     * @param sourceFiles An array of source files
+     * @param transforms An array of Transformers.
+     */
+    export function transformFiles(resolver: EmitResolver, host: EmitHost, sourceFiles: SourceFile[], transformers: Transformer[]): TransformationResult {
+        const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
+        const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
+        const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
+
+        let lexicalEnvironmentStackOffset = 0;
+        let hoistedVariableDeclarations: VariableDeclaration[];
+        let hoistedFunctionDeclarations: FunctionDeclaration[];
+        let lexicalEnvironmentDisabled: boolean;
+
+        // The transformation context is provided to each transformer as part of transformer
+        // initialization.
+        const context: TransformationContext = {
+            getCompilerOptions: () => host.getCompilerOptions(),
+            getEmitResolver: () => resolver,
+            getEmitHost: () => host,
+            hoistVariableDeclaration,
+            hoistFunctionDeclaration,
+            startLexicalEnvironment,
+            endLexicalEnvironment,
+            onSubstituteNode: (emitContext, node) => node,
+            enableSubstitution,
+            isSubstitutionEnabled,
+            onEmitNode: (node, emitContext, emitCallback) => emitCallback(node, emitContext),
+            enableEmitNotification,
+            isEmitNotificationEnabled
+        };
+
+        // Chain together and initialize each transformer.
+        const transformation = chain(...transformers)(context);
+
+        // Transform each source file.
+        const transformed = map(sourceFiles, transformSourceFile);
+
+        // Disable modification of the lexical environment.
+        lexicalEnvironmentDisabled = true;
+
+        return {
+            transformed,
+            emitNodeWithSubstitution,
+            emitNodeWithNotification
+        };
+
+        /**
+         * Transforms a source file.
+         *
+         * @param sourceFile The source file to transform.
+         */
+        function transformSourceFile(sourceFile: SourceFile) {
+            if (isDeclarationFile(sourceFile)) {
+                return sourceFile;
+            }
+
+            return transformation(sourceFile);
+        }
+
+        /**
+         * Enables expression substitutions in the pretty printer for the provided SyntaxKind.
+         */
+        function enableSubstitution(kind: SyntaxKind) {
+            enabledSyntaxKindFeatures[kind] |= SyntaxKindFeatureFlags.Substitution;
+        }
+
+        /**
+         * Determines whether expression substitutions are enabled for the provided node.
+         */
+        function isSubstitutionEnabled(node: Node) {
+            return (enabledSyntaxKindFeatures[node.kind] & SyntaxKindFeatureFlags.Substitution) !== 0
+                && (getEmitFlags(node) & EmitFlags.NoSubstitution) === 0;
+        }
+
+        /**
+         * Emits a node with possible substitution.
+         *
+         * @param emitContext The current emit context.
+         * @param node The node to emit.
+         * @param emitCallback The callback used to emit the node or its substitute.
+         */
+        function emitNodeWithSubstitution(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+            if (node) {
+                if (isSubstitutionEnabled(node)) {
+                    const substitute = context.onSubstituteNode(emitContext, node);
+                    if (substitute && substitute !== node) {
+                        emitCallback(emitContext, substitute);
+                        return;
+                    }
+                }
+
+                emitCallback(emitContext, node);
+            }
+        }
+
+        /**
+         * Enables before/after emit notifications in the pretty printer for the provided SyntaxKind.
+         */
+        function enableEmitNotification(kind: SyntaxKind) {
+            enabledSyntaxKindFeatures[kind] |= SyntaxKindFeatureFlags.EmitNotifications;
+        }
+
+        /**
+         * Determines whether before/after emit notifications should be raised in the pretty
+         * printer when it emits a node.
+         */
+        function isEmitNotificationEnabled(node: Node) {
+            return (enabledSyntaxKindFeatures[node.kind] & SyntaxKindFeatureFlags.EmitNotifications) !== 0
+                || (getEmitFlags(node) & EmitFlags.AdviseOnEmitNode) !== 0;
+        }
+
+        /**
+         * Emits a node with possible emit notification.
+         *
+         * @param emitContext The current emit context.
+         * @param node The node to emit.
+         * @param emitCallback The callback used to emit the node.
+         */
+        function emitNodeWithNotification(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+            if (node) {
+                if (isEmitNotificationEnabled(node)) {
+                    context.onEmitNode(emitContext, node, emitCallback);
+                }
+                else {
+                    emitCallback(emitContext, node);
+                }
+            }
+        }
+
+        /**
+         * Records a hoisted variable declaration for the provided name within a lexical environment.
+         */
+        function hoistVariableDeclaration(name: Identifier): void {
+            Debug.assert(!lexicalEnvironmentDisabled, "Cannot modify the lexical environment during the print phase.");
+            const decl = createVariableDeclaration(name);
+            if (!hoistedVariableDeclarations) {
+                hoistedVariableDeclarations = [decl];
+            }
+            else {
+                hoistedVariableDeclarations.push(decl);
+            }
+        }
+
+        /**
+         * Records a hoisted function declaration within a lexical environment.
+         */
+        function hoistFunctionDeclaration(func: FunctionDeclaration): void {
+            Debug.assert(!lexicalEnvironmentDisabled, "Cannot modify the lexical environment during the print phase.");
+            if (!hoistedFunctionDeclarations) {
+                hoistedFunctionDeclarations = [func];
+            }
+            else {
+                hoistedFunctionDeclarations.push(func);
+            }
+        }
+
+        /**
+         * Starts a new lexical environment. Any existing hoisted variable or function declarations
+         * are pushed onto a stack, and the related storage variables are reset.
+         */
+        function startLexicalEnvironment(): void {
+            Debug.assert(!lexicalEnvironmentDisabled, "Cannot start a lexical environment during the print phase.");
+
+            // Save the current lexical environment. Rather than resizing the array we adjust the
+            // stack size variable. This allows us to reuse existing array slots we've
+            // already allocated between transformations to avoid allocation and GC overhead during
+            // transformation.
+            lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = hoistedVariableDeclarations;
+            lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = hoistedFunctionDeclarations;
+            lexicalEnvironmentStackOffset++;
+            hoistedVariableDeclarations = undefined;
+            hoistedFunctionDeclarations = undefined;
+        }
+
+        /**
+         * Ends a lexical environment. The previous set of hoisted declarations are restored and
+         * any hoisted declarations added in this environment are returned.
+         */
+        function endLexicalEnvironment(): Statement[] {
+            Debug.assert(!lexicalEnvironmentDisabled, "Cannot end a lexical environment during the print phase.");
+
+            let statements: Statement[];
+            if (hoistedVariableDeclarations || hoistedFunctionDeclarations) {
+                if (hoistedFunctionDeclarations) {
+                    statements = [...hoistedFunctionDeclarations];
+                }
+
+                if (hoistedVariableDeclarations) {
+                    const statement = createVariableStatement(
+                        /*modifiers*/ undefined,
+                        createVariableDeclarationList(hoistedVariableDeclarations)
+                    );
+
+                    if (!statements) {
+                        statements = [statement];
+                    }
+                    else {
+                        statements.push(statement);
+                    }
+                }
+            }
+
+            // Restore the previous lexical environment.
+            lexicalEnvironmentStackOffset--;
+            hoistedVariableDeclarations = lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset];
+            hoistedFunctionDeclarations = lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset];
+            return statements;
+        }
+    }
+}

src/compiler/transformers/destructuring.ts

@@ -0,0 +1,445 @@
+/// <reference path="../factory.ts" />
+/// <reference path="../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    /**
+     * Flattens a destructuring assignment expression.
+     *
+     * @param root The destructuring assignment expression.
+     * @param needsValue Indicates whether the value from the right-hand-side of the
+     *                   destructuring assignment is needed as part of a larger expression.
+     * @param recordTempVariable A callback used to record new temporary variables.
+     * @param visitor An optional visitor to use to visit expressions.
+     */
+    export function flattenDestructuringAssignment(
+        context: TransformationContext,
+        node: BinaryExpression,
+        needsValue: boolean,
+        recordTempVariable: (node: Identifier) => void,
+        visitor?: (node: Node) => VisitResult<Node>): Expression {
+
+        if (isEmptyObjectLiteralOrArrayLiteral(node.left)) {
+            const right = node.right;
+            if (isDestructuringAssignment(right)) {
+                return flattenDestructuringAssignment(context, right, needsValue, recordTempVariable, visitor);
+            }
+            else {
+                return node.right;
+            }
+        }
+
+        let location: TextRange = node;
+        let value = node.right;
+        const expressions: Expression[] = [];
+        if (needsValue) {
+            // If the right-hand value of the destructuring assignment needs to be preserved (as
+            // is the case when the destructuring assignmen) is part of a larger expression),
+            // then we need to cache the right-hand value.
+            //
+            // The source map location for the assignment should point to the entire binary
+            // expression.
+            value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, location, emitTempVariableAssignment, visitor);
+        }
+        else if (nodeIsSynthesized(node)) {
+            // Generally, the source map location for a destructuring assignment is the root
+            // expression.
+            //
+            // However, if the root expression is synthesized (as in the case
+            // of the initializer when transforming a ForOfStatement), then the source map
+            // location should point to the right-hand value of the expression.
+            location = value;
+        }
+
+        flattenDestructuring(context, node, value, location, emitAssignment, emitTempVariableAssignment, visitor);
+
+        if (needsValue) {
+            expressions.push(value);
+        }
+
+        const expression = inlineExpressions(expressions);
+        aggregateTransformFlags(expression);
+        return expression;
+
+        function emitAssignment(name: Identifier, value: Expression, location: TextRange) {
+            const expression = createAssignment(name, value, location);
+
+            // NOTE: this completely disables source maps, but aligns with the behavior of
+            //       `emitAssignment` in the old emitter.
+            setEmitFlags(expression, EmitFlags.NoNestedSourceMaps);
+
+            aggregateTransformFlags(expression);
+            expressions.push(expression);
+        }
+
+        function emitTempVariableAssignment(value: Expression, location: TextRange) {
+            const name = createTempVariable(recordTempVariable);
+            emitAssignment(name, value, location);
+            return name;
+        }
+    }
+
+    /**
+     * Flattens binding patterns in a parameter declaration.
+     *
+     * @param node The ParameterDeclaration to flatten.
+     * @param value The rhs value for the binding pattern.
+     * @param visitor An optional visitor to use to visit expressions.
+     */
+    export function flattenParameterDestructuring(
+        context: TransformationContext,
+        node: ParameterDeclaration,
+        value: Expression,
+        visitor?: (node: Node) => VisitResult<Node>) {
+        const declarations: VariableDeclaration[] = [];
+
+        flattenDestructuring(context, node, value, node, emitAssignment, emitTempVariableAssignment, visitor);
+
+        return declarations;
+
+        function emitAssignment(name: Identifier, value: Expression, location: TextRange) {
+            const declaration = createVariableDeclaration(name, /*type*/ undefined, value, location);
+
+            // NOTE: this completely disables source maps, but aligns with the behavior of
+            //       `emitAssignment` in the old emitter.
+            setEmitFlags(declaration, EmitFlags.NoNestedSourceMaps);
+
+            aggregateTransformFlags(declaration);
+            declarations.push(declaration);
+        }
+
+        function emitTempVariableAssignment(value: Expression, location: TextRange) {
+            const name = createTempVariable(/*recordTempVariable*/ undefined);
+            emitAssignment(name, value, location);
+            return name;
+        }
+    }
+
+    /**
+     * Flattens binding patterns in a variable declaration.
+     *
+     * @param node The VariableDeclaration to flatten.
+     * @param value An optional rhs value for the binding pattern.
+     * @param visitor An optional visitor to use to visit expressions.
+     */
+    export function flattenVariableDestructuring(
+        context: TransformationContext,
+        node: VariableDeclaration,
+        value?: Expression,
+        visitor?: (node: Node) => VisitResult<Node>,
+        recordTempVariable?: (node: Identifier) => void) {
+        const declarations: VariableDeclaration[] = [];
+
+        let pendingAssignments: Expression[];
+        flattenDestructuring(context, node, value, node, emitAssignment, emitTempVariableAssignment, visitor);
+
+        return declarations;
+
+        function emitAssignment(name: Identifier, value: Expression, location: TextRange, original: Node) {
+            if (pendingAssignments) {
+                pendingAssignments.push(value);
+                value = inlineExpressions(pendingAssignments);
+                pendingAssignments = undefined;
+            }
+
+            const declaration = createVariableDeclaration(name, /*type*/ undefined, value, location);
+            declaration.original = original;
+
+            // NOTE: this completely disables source maps, but aligns with the behavior of
+            //       `emitAssignment` in the old emitter.
+            setEmitFlags(declaration, EmitFlags.NoNestedSourceMaps);
+
+            declarations.push(declaration);
+            aggregateTransformFlags(declaration);
+        }
+
+        function emitTempVariableAssignment(value: Expression, location: TextRange) {
+            const name = createTempVariable(recordTempVariable);
+            if (recordTempVariable) {
+                const assignment = createAssignment(name, value, location);
+                if (pendingAssignments) {
+                    pendingAssignments.push(assignment);
+                }
+                else {
+                    pendingAssignments = [assignment];
+                }
+            }
+            else {
+                emitAssignment(name, value, location, /*original*/ undefined);
+            }
+            return name;
+        }
+    }
+
+    /**
+     * Flattens binding patterns in a variable declaration and transforms them into an expression.
+     *
+     * @param node The VariableDeclaration to flatten.
+     * @param recordTempVariable A callback used to record new temporary variables.
+     * @param nameSubstitution An optional callback used to substitute binding names.
+     * @param visitor An optional visitor to use to visit expressions.
+     */
+    export function flattenVariableDestructuringToExpression(
+        context: TransformationContext,
+        node: VariableDeclaration,
+        recordTempVariable: (name: Identifier) => void,
+        nameSubstitution?: (name: Identifier) => Expression,
+        visitor?: (node: Node) => VisitResult<Node>) {
+
+        const pendingAssignments: Expression[] = [];
+
+        flattenDestructuring(context, node, /*value*/ undefined, node, emitAssignment, emitTempVariableAssignment, visitor);
+
+        const expression = inlineExpressions(pendingAssignments);
+        aggregateTransformFlags(expression);
+        return expression;
+
+        function emitAssignment(name: Identifier, value: Expression, location: TextRange, original: Node) {
+            const left = nameSubstitution && nameSubstitution(name) || name;
+            emitPendingAssignment(left, value, location, original);
+        }
+
+        function emitTempVariableAssignment(value: Expression, location: TextRange) {
+            const name = createTempVariable(recordTempVariable);
+            emitPendingAssignment(name, value, location, /*original*/ undefined);
+            return name;
+        }
+
+        function emitPendingAssignment(name: Expression, value: Expression, location: TextRange, original: Node) {
+            const expression = createAssignment(name, value, location);
+            expression.original = original;
+
+            // NOTE: this completely disables source maps, but aligns with the behavior of
+            //       `emitAssignment` in the old emitter.
+            setEmitFlags(expression, EmitFlags.NoNestedSourceMaps);
+
+            pendingAssignments.push(expression);
+            return expression;
+        }
+    }
+
+    function flattenDestructuring(
+        context: TransformationContext,
+        root: VariableDeclaration | ParameterDeclaration | BindingElement | BinaryExpression,
+        value: Expression,
+        location: TextRange,
+        emitAssignment: (name: Identifier, value: Expression, location: TextRange, original: Node) => void,
+        emitTempVariableAssignment: (value: Expression, location: TextRange) => Identifier,
+        visitor?: (node: Node) => VisitResult<Node>) {
+        if (value && visitor) {
+            value = visitNode(value, visitor, isExpression);
+        }
+
+        if (isBinaryExpression(root)) {
+            emitDestructuringAssignment(root.left, value, location);
+        }
+        else {
+            emitBindingElement(root, value);
+        }
+
+        function emitDestructuringAssignment(bindingTarget: Expression | ShorthandPropertyAssignment, value: Expression, location: TextRange) {
+            // When emitting target = value use source map node to highlight, including any temporary assignments needed for this
+            let target: Expression;
+            if (isShorthandPropertyAssignment(bindingTarget)) {
+                const initializer = visitor
+                    ? visitNode(bindingTarget.objectAssignmentInitializer, visitor, isExpression)
+                    : bindingTarget.objectAssignmentInitializer;
+
+                if (initializer) {
+                    value = createDefaultValueCheck(value, initializer, location);
+                }
+
+                target = bindingTarget.name;
+            }
+            else if (isBinaryExpression(bindingTarget) && bindingTarget.operatorToken.kind === SyntaxKind.EqualsToken) {
+                const initializer = visitor
+                    ? visitNode(bindingTarget.right, visitor, isExpression)
+                    : bindingTarget.right;
+
+                value = createDefaultValueCheck(value, initializer, location);
+                target = bindingTarget.left;
+            }
+            else {
+                target = bindingTarget;
+            }
+
+            if (target.kind === SyntaxKind.ObjectLiteralExpression) {
+                emitObjectLiteralAssignment(<ObjectLiteralExpression>target, value, location);
+            }
+            else if (target.kind === SyntaxKind.ArrayLiteralExpression) {
+                emitArrayLiteralAssignment(<ArrayLiteralExpression>target, value, location);
+            }
+            else {
+                const name = getMutableClone(<Identifier>target);
+                setSourceMapRange(name, target);
+                setCommentRange(name, target);
+                emitAssignment(name, value, location, /*original*/ undefined);
+            }
+        }
+
+        function emitObjectLiteralAssignment(target: ObjectLiteralExpression, value: Expression, location: TextRange) {
+            const properties = target.properties;
+            if (properties.length !== 1) {
+                // For anything but a single element destructuring we need to generate a temporary
+                // to ensure value is evaluated exactly once.
+                // When doing so we want to hightlight the passed in source map node since thats the one needing this temp assignment
+                value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, location, emitTempVariableAssignment);
+            }
+
+            for (const p of properties) {
+                if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) {
+                    const propName = <Identifier | LiteralExpression>(<PropertyAssignment>p).name;
+                    const target = p.kind === SyntaxKind.ShorthandPropertyAssignment ? <ShorthandPropertyAssignment>p : (<PropertyAssignment>p).initializer || propName;
+                    // Assignment for target = value.propName should highligh whole property, hence use p as source map node
+                    emitDestructuringAssignment(target, createDestructuringPropertyAccess(value, propName), p);
+                }
+            }
+        }
+
+        function emitArrayLiteralAssignment(target: ArrayLiteralExpression, value: Expression, location: TextRange) {
+            const elements = target.elements;
+            const numElements = elements.length;
+            if (numElements !== 1) {
+                // For anything but a single element destructuring we need to generate a temporary
+                // to ensure value is evaluated exactly once.
+                // When doing so we want to hightlight the passed in source map node since thats the one needing this temp assignment
+                value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, location, emitTempVariableAssignment);
+            }
+
+            for (let i = 0; i < numElements; i++) {
+                const e = elements[i];
+                if (e.kind !== SyntaxKind.OmittedExpression) {
+                    // Assignment for target = value.propName should highligh whole property, hence use e as source map node
+                    if (e.kind !== SyntaxKind.SpreadElementExpression) {
+                        emitDestructuringAssignment(e, createElementAccess(value, createLiteral(i)), e);
+                    }
+                    else if (i === numElements - 1) {
+                        emitDestructuringAssignment((<SpreadElementExpression>e).expression, createArraySlice(value, i), e);
+                    }
+                }
+            }
+        }
+
+        function emitBindingElement(target: VariableDeclaration | ParameterDeclaration | BindingElement, value: Expression) {
+            // Any temporary assignments needed to emit target = value should point to target
+            const initializer = visitor ? visitNode(target.initializer, visitor, isExpression) : target.initializer;
+            if (initializer) {
+                // Combine value and initializer
+                value = value ? createDefaultValueCheck(value, initializer, target) : initializer;
+            }
+            else if (!value) {
+                // Use 'void 0' in absence of value and initializer
+                value = createVoidZero();
+            }
+
+            const name = target.name;
+            if (isBindingPattern(name)) {
+                const elements = name.elements;
+                const numElements = elements.length;
+                if (numElements !== 1) {
+                    // For anything other than a single-element destructuring we need to generate a temporary
+                    // to ensure value is evaluated exactly once. Additionally, if we have zero elements
+                    // we need to emit *something* to ensure that in case a 'var' keyword was already emitted,
+                    // so in that case, we'll intentionally create that temporary.
+                    value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ numElements !== 0, target, emitTempVariableAssignment);
+                }
+                for (let i = 0; i < numElements; i++) {
+                    const element = elements[i];
+                    if (isOmittedExpression(element)) {
+                        continue;
+                    }
+                    else if (name.kind === SyntaxKind.ObjectBindingPattern) {
+                        // Rewrite element to a declaration with an initializer that fetches property
+                        const propName = element.propertyName || <Identifier>element.name;
+                        emitBindingElement(element, createDestructuringPropertyAccess(value, propName));
+                    }
+                    else {
+                        if (!element.dotDotDotToken) {
+                            // Rewrite element to a declaration that accesses array element at index i
+                            emitBindingElement(element, createElementAccess(value, i));
+                        }
+                        else if (i === numElements - 1) {
+                            emitBindingElement(element, createArraySlice(value, i));
+                        }
+                    }
+                }
+            }
+            else {
+                emitAssignment(name, value, target, target);
+            }
+        }
+
+        function createDefaultValueCheck(value: Expression, defaultValue: Expression, location: TextRange): Expression {
+            value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, location, emitTempVariableAssignment);
+            return createConditional(
+                createStrictEquality(value, createVoidZero()),
+                createToken(SyntaxKind.QuestionToken),
+                defaultValue,
+                createToken(SyntaxKind.ColonToken),
+                value
+            );
+        }
+
+        /**
+         * Creates either a PropertyAccessExpression or an ElementAccessExpression for the
+         * right-hand side of a transformed destructuring assignment.
+         *
+         * @param expression The right-hand expression that is the source of the property.
+         * @param propertyName The destructuring property name.
+         */
+        function createDestructuringPropertyAccess(expression: Expression, propertyName: PropertyName): LeftHandSideExpression {
+            if (isComputedPropertyName(propertyName)) {
+                return createElementAccess(
+                    expression,
+                    ensureIdentifier(propertyName.expression, /*reuseIdentifierExpressions*/ false, /*location*/ propertyName, emitTempVariableAssignment)
+                );
+            }
+            else if (isLiteralExpression(propertyName)) {
+                const clone = getSynthesizedClone(propertyName);
+                clone.text = unescapeIdentifier(clone.text);
+                return createElementAccess(expression, clone);
+            }
+            else {
+                if (isGeneratedIdentifier(propertyName)) {
+                    const clone = getSynthesizedClone(propertyName);
+                    clone.text = unescapeIdentifier(clone.text);
+                    return createPropertyAccess(expression, clone);
+                }
+                else {
+                    return createPropertyAccess(expression, createIdentifier(unescapeIdentifier(propertyName.text)));
+                }
+            }
+        }
+    }
+
+    /**
+     * Ensures that there exists a declared identifier whose value holds the given expression.
+     * This function is useful to ensure that the expression's value can be read from in subsequent expressions.
+     * Unless 'reuseIdentifierExpressions' is false, 'value' will be returned if it is just an identifier.
+     *
+     * @param value the expression whose value needs to be bound.
+     * @param reuseIdentifierExpressions true if identifier expressions can simply be returned;
+     *                                   false if it is necessary to always emit an identifier.
+     * @param location The location to use for source maps and comments.
+     * @param emitTempVariableAssignment A callback used to emit a temporary variable.
+     * @param visitor An optional callback used to visit the value.
+     */
+    function ensureIdentifier(
+        value: Expression,
+        reuseIdentifierExpressions: boolean,
+        location: TextRange,
+        emitTempVariableAssignment: (value: Expression, location: TextRange) => Identifier,
+        visitor?: (node: Node) => VisitResult<Node>) {
+
+        if (isIdentifier(value) && reuseIdentifierExpressions) {
+            return value;
+        }
+        else {
+            if (visitor) {
+                value = visitNode(value, visitor, isExpression);
+            }
+
+            return emitTempVariableAssignment(value, location);
+        }
+    }
+}

src/compiler/transformers/es2016.ts

@@ -0,0 +1,101 @@
+/// <reference path="../factory.ts" />
+/// <reference path="../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    export function transformES2016(context: TransformationContext) {
+        const { hoistVariableDeclaration } = context;
+
+        return transformSourceFile;
+
+        function transformSourceFile(node: SourceFile) {
+            if (isDeclarationFile(node)) {
+                return node;
+            }
+
+            return visitEachChild(node, visitor, context);
+        }
+
+        function visitor(node: Node): VisitResult<Node> {
+            if (node.transformFlags & TransformFlags.ES2016) {
+                return visitorWorker(node);
+            }
+            else if (node.transformFlags & TransformFlags.ContainsES2016) {
+                return visitEachChild(node, visitor, context);
+            }
+            else {
+                return node;
+            }
+        }
+
+        function visitorWorker(node: Node): VisitResult<Node> {
+            switch (node.kind) {
+                case SyntaxKind.BinaryExpression:
+                    return visitBinaryExpression(<BinaryExpression>node);
+
+                default:
+                    Debug.failBadSyntaxKind(node);
+                    return visitEachChild(node, visitor, context);
+            }
+        }
+
+        function visitBinaryExpression(node: BinaryExpression): Expression {
+            // We are here because ES2016 adds support for the exponentiation operator.
+            const left = visitNode(node.left, visitor, isExpression);
+            const right = visitNode(node.right, visitor, isExpression);
+            if (node.operatorToken.kind === SyntaxKind.AsteriskAsteriskEqualsToken) {
+                let target: Expression;
+                let value: Expression;
+                if (isElementAccessExpression(left)) {
+                    // Transforms `a[x] **= b` into `(_a = a)[_x = x] = Math.pow(_a[_x], b)`
+                    const expressionTemp = createTempVariable(hoistVariableDeclaration);
+
+                    const argumentExpressionTemp = createTempVariable(hoistVariableDeclaration);
+
+                    target = createElementAccess(
+                        createAssignment(expressionTemp, left.expression, /*location*/ left.expression),
+                        createAssignment(argumentExpressionTemp, left.argumentExpression, /*location*/ left.argumentExpression),
+                        /*location*/ left
+                    );
+
+                    value = createElementAccess(
+                        expressionTemp,
+                        argumentExpressionTemp,
+                        /*location*/ left
+                    );
+                }
+                else if (isPropertyAccessExpression(left)) {
+                    // Transforms `a.x **= b` into `(_a = a).x = Math.pow(_a.x, b)`
+                    const expressionTemp = createTempVariable(hoistVariableDeclaration);
+
+                    target = createPropertyAccess(
+                        createAssignment(expressionTemp, left.expression, /*location*/ left.expression),
+                        left.name,
+                        /*location*/ left
+                    );
+
+                    value = createPropertyAccess(
+                        expressionTemp,
+                        left.name,
+                        /*location*/ left
+                    );
+                }
+                else {
+                    // Transforms `a **= b` into `a = Math.pow(a, b)`
+                    target = left;
+                    value = left;
+                }
+
+                return createAssignment(target, createMathPow(value, right, /*location*/ node), /*location*/ node);
+            }
+            else if (node.operatorToken.kind === SyntaxKind.AsteriskAsteriskToken) {
+                // Transforms `a ** b` into `Math.pow(a, b)`
+                return createMathPow(left, right, /*location*/ node);
+            }
+            else {
+                Debug.failBadSyntaxKind(node);
+                return visitEachChild(node, visitor, context);
+            }
+        }
+    }
+}

src/compiler/transformers/es2017.ts

@@ -0,0 +1,510 @@
+/// <reference path="../factory.ts" />
+/// <reference path="../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    type SuperContainer = ClassDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration;
+
+    export function transformES2017(context: TransformationContext) {
+
+        const enum ES2017SubstitutionFlags {
+            /** Enables substitutions for async methods with `super` calls. */
+            AsyncMethodsWithSuper = 1 << 0
+        }
+
+        const {
+            startLexicalEnvironment,
+            endLexicalEnvironment,
+        } = context;
+
+        const resolver = context.getEmitResolver();
+        const compilerOptions = context.getCompilerOptions();
+        const languageVersion = getEmitScriptTarget(compilerOptions);
+
+        // These variables contain state that changes as we descend into the tree.
+        let currentSourceFileExternalHelpersModuleName: Identifier;
+        /**
+         * Keeps track of whether expression substitution has been enabled for specific edge cases.
+         * They are persisted between each SourceFile transformation and should not be reset.
+         */
+        let enabledSubstitutions: ES2017SubstitutionFlags;
+
+        /**
+         * Keeps track of whether  we are within any containing namespaces when performing
+         * just-in-time substitution while printing an expression identifier.
+         */
+        let applicableSubstitutions: ES2017SubstitutionFlags;
+
+        /**
+         * This keeps track of containers where `super` is valid, for use with
+         * just-in-time substitution for `super` expressions inside of async methods.
+         */
+        let currentSuperContainer: SuperContainer;
+
+        // Save the previous transformation hooks.
+        const previousOnEmitNode = context.onEmitNode;
+        const previousOnSubstituteNode = context.onSubstituteNode;
+
+        // Set new transformation hooks.
+        context.onEmitNode = onEmitNode;
+        context.onSubstituteNode = onSubstituteNode;
+
+        let currentScope: SourceFile | Block | ModuleBlock | CaseBlock;
+
+        return transformSourceFile;
+
+        function transformSourceFile(node: SourceFile) {
+            if (isDeclarationFile(node)) {
+                return node;
+            }
+
+            currentSourceFileExternalHelpersModuleName = node.externalHelpersModuleName;
+
+            return visitEachChild(node, visitor, context);
+        }
+
+        function visitor(node: Node): VisitResult<Node> {
+            if (node.transformFlags & TransformFlags.ES2017) {
+                return visitorWorker(node);
+            }
+            else if (node.transformFlags & TransformFlags.ContainsES2017) {
+                return visitEachChild(node, visitor, context);
+            }
+
+            return node;
+        }
+
+        function visitorWorker(node: Node): VisitResult<Node> {
+            switch (node.kind) {
+                case SyntaxKind.AsyncKeyword:
+                    // ES2017 async modifier should be elided for targets < ES2017
+                    return undefined;
+
+                case SyntaxKind.AwaitExpression:
+                    // ES2017 'await' expressions must be transformed for targets < ES2017.
+                    return visitAwaitExpression(<AwaitExpression>node);
+
+                case SyntaxKind.MethodDeclaration:
+                    // ES2017 method declarations may be 'async'
+                    return visitMethodDeclaration(<MethodDeclaration>node);
+
+                case SyntaxKind.FunctionDeclaration:
+                    // ES2017 function declarations may be 'async'
+                    return visitFunctionDeclaration(<FunctionDeclaration>node);
+
+                case SyntaxKind.FunctionExpression:
+                    // ES2017 function expressions may be 'async'
+                    return visitFunctionExpression(<FunctionExpression>node);
+
+                case SyntaxKind.ArrowFunction:
+                    // ES2017 arrow functions may be 'async'
+                    return visitArrowFunction(<ArrowFunction>node);
+
+                default:
+                    Debug.failBadSyntaxKind(node);
+                    return node;
+            }
+        }
+
+        /**
+         * Visits an await expression.
+         *
+         * This function will be called any time a ES2017 await expression is encountered.
+         *
+         * @param node The await expression node.
+         */
+        function visitAwaitExpression(node: AwaitExpression): Expression {
+            return setOriginalNode(
+                createYield(
+                    /*asteriskToken*/ undefined,
+                    visitNode(node.expression, visitor, isExpression),
+                    /*location*/ node
+                ),
+                node
+            );
+        }
+
+        /**
+         * Visits a method declaration of a class.
+         *
+         * This function will be called when one of the following conditions are met:
+         * - The node is marked as async
+         *
+         * @param node The method node.
+         */
+        function visitMethodDeclaration(node: MethodDeclaration) {
+            if (!isAsyncFunctionLike(node)) {
+                return node;
+            }
+            const method = createMethod(
+                /*decorators*/ undefined,
+                visitNodes(node.modifiers, visitor, isModifier),
+                node.asteriskToken,
+                node.name,
+                /*typeParameters*/ undefined,
+                visitNodes(node.parameters, visitor, isParameter),
+                /*type*/ undefined,
+                transformFunctionBody(node),
+                /*location*/ node
+            );
+
+            // While we emit the source map for the node after skipping decorators and modifiers,
+            // we need to emit the comments for the original range.
+            setCommentRange(method, node);
+            setSourceMapRange(method, moveRangePastDecorators(node));
+            setOriginalNode(method, node);
+
+            return method;
+        }
+
+        /**
+         * Visits a function declaration.
+         *
+         * This function will be called when one of the following conditions are met:
+         * - The node is marked async
+         *
+         * @param node The function node.
+         */
+        function visitFunctionDeclaration(node: FunctionDeclaration): VisitResult<Statement> {
+            if (!isAsyncFunctionLike(node)) {
+                return node;
+            }
+            const func = createFunctionDeclaration(
+                /*decorators*/ undefined,
+                visitNodes(node.modifiers, visitor, isModifier),
+                node.asteriskToken,
+                node.name,
+                /*typeParameters*/ undefined,
+                visitNodes(node.parameters, visitor, isParameter),
+                /*type*/ undefined,
+                transformFunctionBody(node),
+                /*location*/ node
+            );
+            setOriginalNode(func, node);
+
+            return func;
+        }
+
+        /**
+         * Visits a function expression node.
+         *
+         * This function will be called when one of the following conditions are met:
+         * - The node is marked async
+         *
+         * @param node The function expression node.
+         */
+        function visitFunctionExpression(node: FunctionExpression): Expression {
+            if (!isAsyncFunctionLike(node)) {
+                return node;
+            }
+            if (nodeIsMissing(node.body)) {
+                return createOmittedExpression();
+            }
+
+            const func = createFunctionExpression(
+                /*modifiers*/ undefined,
+                node.asteriskToken,
+                node.name,
+                /*typeParameters*/ undefined,
+                visitNodes(node.parameters, visitor, isParameter),
+                /*type*/ undefined,
+                transformFunctionBody(node),
+                /*location*/ node
+            );
+
+            setOriginalNode(func, node);
+
+            return func;
+        }
+
+        /**
+         * @remarks
+         * This function will be called when one of the following conditions are met:
+         * - The node is marked async
+         */
+        function visitArrowFunction(node: ArrowFunction) {
+            if (!isAsyncFunctionLike(node)) {
+                return node;
+            }
+            const func = createArrowFunction(
+                visitNodes(node.modifiers, visitor, isModifier),
+                /*typeParameters*/ undefined,
+                visitNodes(node.parameters, visitor, isParameter),
+                /*type*/ undefined,
+                node.equalsGreaterThanToken,
+                transformConciseBody(node),
+                /*location*/ node
+            );
+
+            setOriginalNode(func, node);
+
+            return func;
+        }
+
+        function transformFunctionBody(node: MethodDeclaration | AccessorDeclaration | FunctionDeclaration | FunctionExpression): FunctionBody {
+            return <FunctionBody>transformAsyncFunctionBody(node);
+        }
+
+        function transformConciseBody(node: ArrowFunction): ConciseBody {
+            return transformAsyncFunctionBody(node);
+        }
+
+        function transformFunctionBodyWorker(body: Block, start = 0) {
+            const savedCurrentScope = currentScope;
+            currentScope = body;
+            startLexicalEnvironment();
+
+            const statements = visitNodes(body.statements, visitor, isStatement, start);
+            const visited = updateBlock(body, statements);
+            const declarations = endLexicalEnvironment();
+            currentScope = savedCurrentScope;
+            return mergeFunctionBodyLexicalEnvironment(visited, declarations);
+        }
+
+        function transformAsyncFunctionBody(node: FunctionLikeDeclaration): ConciseBody | FunctionBody {
+            const nodeType = node.original ? (<FunctionLikeDeclaration>node.original).type : node.type;
+            const promiseConstructor = languageVersion < ScriptTarget.ES2015 ? getPromiseConstructor(nodeType) : undefined;
+            const isArrowFunction = node.kind === SyntaxKind.ArrowFunction;
+            const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & NodeCheckFlags.CaptureArguments) !== 0;
+
+            // An async function is emit as an outer function that calls an inner
+            // generator function. To preserve lexical bindings, we pass the current
+            // `this` and `arguments` objects to `__awaiter`. The generator function
+            // passed to `__awaiter` is executed inside of the callback to the
+            // promise constructor.
+
+
+            if (!isArrowFunction) {
+                const statements: Statement[] = [];
+                const statementOffset = addPrologueDirectives(statements, (<Block>node.body).statements, /*ensureUseStrict*/ false, visitor);
+                statements.push(
+                    createReturn(
+                        createAwaiterHelper(
+                            currentSourceFileExternalHelpersModuleName,
+                            hasLexicalArguments,
+                            promiseConstructor,
+                            transformFunctionBodyWorker(<Block>node.body, statementOffset)
+                        )
+                    )
+                );
+
+                const block = createBlock(statements, /*location*/ node.body, /*multiLine*/ true);
+
+                // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
+                // This step isn't needed if we eventually transform this to ES5.
+                if (languageVersion >= ScriptTarget.ES2015) {
+                    if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuperBinding) {
+                        enableSubstitutionForAsyncMethodsWithSuper();
+                        setEmitFlags(block, EmitFlags.EmitAdvancedSuperHelper);
+                    }
+                    else if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.AsyncMethodWithSuper) {
+                        enableSubstitutionForAsyncMethodsWithSuper();
+                        setEmitFlags(block, EmitFlags.EmitSuperHelper);
+                    }
+                }
+
+                return block;
+            }
+            else {
+                return createAwaiterHelper(
+                    currentSourceFileExternalHelpersModuleName,
+                    hasLexicalArguments,
+                    promiseConstructor,
+                    <Block>transformConciseBodyWorker(node.body, /*forceBlockFunctionBody*/ true)
+                );
+            }
+        }
+
+        function transformConciseBodyWorker(body: Block | Expression, forceBlockFunctionBody: boolean) {
+            if (isBlock(body)) {
+                return transformFunctionBodyWorker(body);
+            }
+            else {
+                startLexicalEnvironment();
+                const visited: Expression | Block = visitNode(body, visitor, isConciseBody);
+                const declarations = endLexicalEnvironment();
+                const merged = mergeFunctionBodyLexicalEnvironment(visited, declarations);
+                if (forceBlockFunctionBody && !isBlock(merged)) {
+                    return createBlock([
+                        createReturn(<Expression>merged)
+                    ]);
+                }
+                else {
+                    return merged;
+                }
+            }
+        }
+
+        function getPromiseConstructor(type: TypeNode) {
+            const typeName = getEntityNameFromTypeNode(type);
+            if (typeName && isEntityName(typeName)) {
+                const serializationKind = resolver.getTypeReferenceSerializationKind(typeName);
+                if (serializationKind === TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue
+                    || serializationKind === TypeReferenceSerializationKind.Unknown) {
+                    return typeName;
+                }
+            }
+
+            return undefined;
+        }
+
+        function enableSubstitutionForAsyncMethodsWithSuper() {
+            if ((enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper) === 0) {
+                enabledSubstitutions |= ES2017SubstitutionFlags.AsyncMethodsWithSuper;
+
+                // We need to enable substitutions for call, property access, and element access
+                // if we need to rewrite super calls.
+                context.enableSubstitution(SyntaxKind.CallExpression);
+                context.enableSubstitution(SyntaxKind.PropertyAccessExpression);
+                context.enableSubstitution(SyntaxKind.ElementAccessExpression);
+
+                // We need to be notified when entering and exiting declarations that bind super.
+                context.enableEmitNotification(SyntaxKind.ClassDeclaration);
+                context.enableEmitNotification(SyntaxKind.MethodDeclaration);
+                context.enableEmitNotification(SyntaxKind.GetAccessor);
+                context.enableEmitNotification(SyntaxKind.SetAccessor);
+                context.enableEmitNotification(SyntaxKind.Constructor);
+            }
+        }
+
+        function substituteExpression(node: Expression) {
+            switch (node.kind) {
+                case SyntaxKind.PropertyAccessExpression:
+                    return substitutePropertyAccessExpression(<PropertyAccessExpression>node);
+                case SyntaxKind.ElementAccessExpression:
+                    return substituteElementAccessExpression(<ElementAccessExpression>node);
+                case SyntaxKind.CallExpression:
+                    if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper) {
+                        return substituteCallExpression(<CallExpression>node);
+                    }
+                    break;
+            }
+
+            return node;
+        }
+
+        function substitutePropertyAccessExpression(node: PropertyAccessExpression) {
+            if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && node.expression.kind === SyntaxKind.SuperKeyword) {
+                const flags = getSuperContainerAsyncMethodFlags();
+                if (flags) {
+                    return createSuperAccessInAsyncMethod(
+                        createLiteral(node.name.text),
+                        flags,
+                        node
+                    );
+                }
+            }
+
+            return node;
+        }
+
+        function substituteElementAccessExpression(node: ElementAccessExpression) {
+            if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && node.expression.kind === SyntaxKind.SuperKeyword) {
+                const flags = getSuperContainerAsyncMethodFlags();
+                if (flags) {
+                    return createSuperAccessInAsyncMethod(
+                        node.argumentExpression,
+                        flags,
+                        node
+                    );
+                }
+            }
+
+            return node;
+        }
+
+        function substituteCallExpression(node: CallExpression): Expression {
+            const expression = node.expression;
+            if (isSuperProperty(expression)) {
+                const flags = getSuperContainerAsyncMethodFlags();
+                if (flags) {
+                    const argumentExpression = isPropertyAccessExpression(expression)
+                        ? substitutePropertyAccessExpression(expression)
+                        : substituteElementAccessExpression(expression);
+                    return createCall(
+                        createPropertyAccess(argumentExpression, "call"),
+                        /*typeArguments*/ undefined,
+                        [
+                            createThis(),
+                            ...node.arguments
+                        ]
+                    );
+                }
+            }
+            return node;
+        }
+
+        function isSuperContainer(node: Node): node is SuperContainer {
+            const kind = node.kind;
+            return kind === SyntaxKind.ClassDeclaration
+                || kind === SyntaxKind.Constructor
+                || kind === SyntaxKind.MethodDeclaration
+                || kind === SyntaxKind.GetAccessor
+                || kind === SyntaxKind.SetAccessor;
+        }
+
+        /**
+         * Hook for node emit.
+         *
+         * @param node The node to emit.
+         * @param emit A callback used to emit the node in the printer.
+         */
+        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void): void {
+            const savedApplicableSubstitutions = applicableSubstitutions;
+            const savedCurrentSuperContainer = currentSuperContainer;
+            // If we need to support substitutions for `super` in an async method,
+            // we should track it here.
+            if (enabledSubstitutions & ES2017SubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) {
+                currentSuperContainer = node;
+            }
+
+            previousOnEmitNode(emitContext, node, emitCallback);
+
+            applicableSubstitutions = savedApplicableSubstitutions;
+            currentSuperContainer = savedCurrentSuperContainer;
+        }
+
+        /**
+         * Hooks node substitutions.
+         *
+         * @param node The node to substitute.
+         * @param isExpression A value indicating whether the node is to be used in an expression
+         *                     position.
+         */
+        function onSubstituteNode(emitContext: EmitContext, node: Node) {
+            node = previousOnSubstituteNode(emitContext, node);
+            if (emitContext === EmitContext.Expression) {
+                return substituteExpression(<Expression>node);
+            }
+
+            return node;
+        }
+
+        function createSuperAccessInAsyncMethod(argumentExpression: Expression, flags: NodeCheckFlags, location: TextRange): LeftHandSideExpression {
+            if (flags & NodeCheckFlags.AsyncMethodWithSuperBinding) {
+                return createPropertyAccess(
+                    createCall(
+                        createIdentifier("_super"),
+                        /*typeArguments*/ undefined,
+                        [argumentExpression]
+                    ),
+                    "value",
+                    location
+                );
+            }
+            else {
+                return createCall(
+                    createIdentifier("_super"),
+                    /*typeArguments*/ undefined,
+                    [argumentExpression],
+                    location
+                );
+            }
+        }
+
+        function getSuperContainerAsyncMethodFlags() {
+            return currentSuperContainer !== undefined
+                && resolver.getNodeCheckFlags(currentSuperContainer) & (NodeCheckFlags.AsyncMethodWithSuper | NodeCheckFlags.AsyncMethodWithSuperBinding);
+        }
+    }
+}

src/compiler/transformers/jsx.ts

@@ -0,0 +1,535 @@
+/// <reference path="../factory.ts" />
+/// <reference path="../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    const entities: Map<number> = createEntitiesMap();
+
+    export function transformJsx(context: TransformationContext) {
+        const compilerOptions = context.getCompilerOptions();
+        let currentSourceFile: SourceFile;
+        return transformSourceFile;
+
+        /**
+         * Transform JSX-specific syntax in a SourceFile.
+         *
+         * @param node A SourceFile node.
+         */
+        function transformSourceFile(node: SourceFile) {
+            if (isDeclarationFile(node)) {
+                return node;
+            }
+
+            currentSourceFile = node;
+            node = visitEachChild(node, visitor, context);
+            currentSourceFile = undefined;
+            return node;
+        }
+
+        function visitor(node: Node): VisitResult<Node> {
+            if (node.transformFlags & TransformFlags.Jsx) {
+                return visitorWorker(node);
+            }
+            else if (node.transformFlags & TransformFlags.ContainsJsx) {
+                return visitEachChild(node, visitor, context);
+            }
+            else {
+                return node;
+            }
+        }
+
+        function visitorWorker(node: Node): VisitResult<Node> {
+            switch (node.kind) {
+                case SyntaxKind.JsxElement:
+                    return visitJsxElement(<JsxElement>node, /*isChild*/ false);
+
+                case SyntaxKind.JsxSelfClosingElement:
+                    return visitJsxSelfClosingElement(<JsxSelfClosingElement>node, /*isChild*/ false);
+
+                case SyntaxKind.JsxExpression:
+                    return visitJsxExpression(<JsxExpression>node);
+
+                default:
+                    Debug.failBadSyntaxKind(node);
+                    return undefined;
+            }
+        }
+
+        function transformJsxChildToExpression(node: JsxChild): Expression {
+            switch (node.kind) {
+                case SyntaxKind.JsxText:
+                    return visitJsxText(<JsxText>node);
+
+                case SyntaxKind.JsxExpression:
+                    return visitJsxExpression(<JsxExpression>node);
+
+                case SyntaxKind.JsxElement:
+                    return visitJsxElement(<JsxElement>node, /*isChild*/ true);
+
+                case SyntaxKind.JsxSelfClosingElement:
+                    return visitJsxSelfClosingElement(<JsxSelfClosingElement>node, /*isChild*/ true);
+
+                default:
+                    Debug.failBadSyntaxKind(node);
+                    return undefined;
+            }
+        }
+
+        function visitJsxElement(node: JsxElement, isChild: boolean) {
+            return visitJsxOpeningLikeElement(node.openingElement, node.children, isChild, /*location*/ node);
+        }
+
+        function visitJsxSelfClosingElement(node: JsxSelfClosingElement, isChild: boolean) {
+            return visitJsxOpeningLikeElement(node, /*children*/ undefined, isChild, /*location*/ node);
+        }
+
+        function visitJsxOpeningLikeElement(node: JsxOpeningLikeElement, children: JsxChild[], isChild: boolean, location: TextRange) {
+            const tagName = getTagName(node);
+            let objectProperties: Expression;
+            const attrs = node.attributes;
+            if (attrs.length === 0) {
+                // When there are no attributes, React wants "null"
+                objectProperties = createNull();
+            }
+            else {
+                // Map spans of JsxAttribute nodes into object literals and spans
+                // of JsxSpreadAttribute nodes into expressions.
+                const segments = flatten(
+                    spanMap(attrs, isJsxSpreadAttribute, (attrs, isSpread) => isSpread
+                        ? map(attrs, transformJsxSpreadAttributeToExpression)
+                        : createObjectLiteral(map(attrs, transformJsxAttributeToObjectLiteralElement))
+                    )
+                );
+
+                if (isJsxSpreadAttribute(attrs[0])) {
+                    // We must always emit at least one object literal before a spread
+                    // argument.
+                    segments.unshift(createObjectLiteral());
+                }
+
+                // Either emit one big object literal (no spread attribs), or
+                // a call to the __assign helper.
+                objectProperties = singleOrUndefined(segments)
+                    || createAssignHelper(currentSourceFile.externalHelpersModuleName, segments);
+            }
+
+            const element = createReactCreateElement(
+                compilerOptions.reactNamespace,
+                tagName,
+                objectProperties,
+                filter(map(children, transformJsxChildToExpression), isDefined),
+                node,
+                location
+            );
+
+            if (isChild) {
+                startOnNewLine(element);
+            }
+
+            return element;
+        }
+
+        function transformJsxSpreadAttributeToExpression(node: JsxSpreadAttribute) {
+            return visitNode(node.expression, visitor, isExpression);
+        }
+
+        function transformJsxAttributeToObjectLiteralElement(node: JsxAttribute) {
+            const name = getAttributeName(node);
+            const expression = transformJsxAttributeInitializer(node.initializer);
+            return createPropertyAssignment(name, expression);
+        }
+
+        function transformJsxAttributeInitializer(node: StringLiteral | JsxExpression) {
+            if (node === undefined) {
+                return createLiteral(true);
+            }
+            else if (node.kind === SyntaxKind.StringLiteral) {
+                const decoded = tryDecodeEntities((<StringLiteral>node).text);
+                return decoded ? createLiteral(decoded, /*location*/ node) : node;
+            }
+            else if (node.kind === SyntaxKind.JsxExpression) {
+                return visitJsxExpression(<JsxExpression>node);
+            }
+            else {
+                Debug.failBadSyntaxKind(node);
+            }
+        }
+
+        function visitJsxText(node: JsxText) {
+            const text = getTextOfNode(node, /*includeTrivia*/ true);
+            let parts: Expression[];
+            let firstNonWhitespace = 0;
+            let lastNonWhitespace = -1;
+
+            // JSX trims whitespace at the end and beginning of lines, except that the
+            // start/end of a tag is considered a start/end of a line only if that line is
+            // on the same line as the closing tag. See examples in
+            // tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx
+            for (let i = 0; i < text.length; i++) {
+                const c = text.charCodeAt(i);
+                if (isLineBreak(c)) {
+                    if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) {
+                        const part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1);
+                        if (!parts) {
+                            parts = [];
+                        }
+
+                        // We do not escape the string here as that is handled by the printer
+                        // when it emits the literal. We do, however, need to decode JSX entities.
+                        parts.push(createLiteral(decodeEntities(part)));
+                    }
+
+                    firstNonWhitespace = -1;
+                }
+                else if (!isWhiteSpace(c)) {
+                    lastNonWhitespace = i;
+                    if (firstNonWhitespace === -1) {
+                        firstNonWhitespace = i;
+                    }
+                }
+            }
+
+            if (firstNonWhitespace !== -1) {
+                const part = text.substr(firstNonWhitespace);
+                if (!parts) {
+                    parts = [];
+                }
+
+                // We do not escape the string here as that is handled by the printer
+                // when it emits the literal. We do, however, need to decode JSX entities.
+                parts.push(createLiteral(decodeEntities(part)));
+            }
+
+            if (parts) {
+                return reduceLeft(parts, aggregateJsxTextParts);
+            }
+
+            return undefined;
+        }
+
+        /**
+         * Aggregates two expressions by interpolating them with a whitespace literal.
+         */
+        function aggregateJsxTextParts(left: Expression, right: Expression) {
+            return createAdd(createAdd(left, createLiteral(" ")), right);
+        }
+
+        /**
+         * Replace entities like "&nbsp;", "&#123;", and "&#xDEADBEEF;" with the characters they encode.
+         * See https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
+         */
+        function decodeEntities(text: string): string {
+            return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {
+                if (decimal) {
+                    return String.fromCharCode(parseInt(decimal, 10));
+                }
+                else if (hex) {
+                    return String.fromCharCode(parseInt(hex, 16));
+                }
+                else {
+                    const ch = entities[word];
+                    // If this is not a valid entity, then just use `match` (replace it with itself, i.e. don't replace)
+                    return ch ? String.fromCharCode(ch) : match;
+                }
+            });
+        }
+
+        /** Like `decodeEntities` but returns `undefined` if there were no entities to decode. */
+        function tryDecodeEntities(text: string): string | undefined {
+            const decoded = decodeEntities(text);
+            return decoded === text ? undefined : decoded;
+        }
+
+        function getTagName(node: JsxElement | JsxOpeningLikeElement): Expression {
+            if (node.kind === SyntaxKind.JsxElement) {
+                return getTagName((<JsxElement>node).openingElement);
+            }
+            else {
+                const name = (<JsxOpeningLikeElement>node).tagName;
+                if (isIdentifier(name) && isIntrinsicJsxName(name.text)) {
+                    return createLiteral(name.text);
+                }
+                else {
+                    return createExpressionFromEntityName(name);
+                }
+            }
+        }
+
+        /**
+         * Emit an attribute name, which is quoted if it needs to be quoted. Because
+         * these emit into an object literal property name, we don't need to be worried
+         * about keywords, just non-identifier characters
+         */
+        function getAttributeName(node: JsxAttribute): StringLiteral | Identifier {
+            const name = node.name;
+            if (/^[A-Za-z_]\w*$/.test(name.text)) {
+                return name;
+            }
+            else {
+                return createLiteral(name.text);
+            }
+        }
+
+        function visitJsxExpression(node: JsxExpression) {
+            return visitNode(node.expression, visitor, isExpression);
+        }
+    }
+
+    function createEntitiesMap(): Map<number> {
+        return createMap<number>({
+            "quot": 0x0022,
+            "amp": 0x0026,
+            "apos": 0x0027,
+            "lt": 0x003C,
+            "gt": 0x003E,
+            "nbsp": 0x00A0,
+            "iexcl": 0x00A1,
+            "cent": 0x00A2,
+            "pound": 0x00A3,
+            "curren": 0x00A4,
+            "yen": 0x00A5,
+            "brvbar": 0x00A6,
+            "sect": 0x00A7,
+            "uml": 0x00A8,
+            "copy": 0x00A9,
+            "ordf": 0x00AA,
+            "laquo": 0x00AB,
+            "not": 0x00AC,
+            "shy": 0x00AD,
+            "reg": 0x00AE,
+            "macr": 0x00AF,
+            "deg": 0x00B0,
+            "plusmn": 0x00B1,
+            "sup2": 0x00B2,
+            "sup3": 0x00B3,
+            "acute": 0x00B4,
+            "micro": 0x00B5,
+            "para": 0x00B6,
+            "middot": 0x00B7,
+            "cedil": 0x00B8,
+            "sup1": 0x00B9,
+            "ordm": 0x00BA,
+            "raquo": 0x00BB,
+            "frac14": 0x00BC,
+            "frac12": 0x00BD,
+            "frac34": 0x00BE,
+            "iquest": 0x00BF,
+            "Agrave": 0x00C0,
+            "Aacute": 0x00C1,
+            "Acirc": 0x00C2,
+            "Atilde": 0x00C3,
+            "Auml": 0x00C4,
+            "Aring": 0x00C5,
+            "AElig": 0x00C6,
+            "Ccedil": 0x00C7,
+            "Egrave": 0x00C8,
+            "Eacute": 0x00C9,
+            "Ecirc": 0x00CA,
+            "Euml": 0x00CB,
+            "Igrave": 0x00CC,
+            "Iacute": 0x00CD,
+            "Icirc": 0x00CE,
+            "Iuml": 0x00CF,
+            "ETH": 0x00D0,
+            "Ntilde": 0x00D1,
+            "Ograve": 0x00D2,
+            "Oacute": 0x00D3,
+            "Ocirc": 0x00D4,
+            "Otilde": 0x00D5,
+            "Ouml": 0x00D6,
+            "times": 0x00D7,
+            "Oslash": 0x00D8,
+            "Ugrave": 0x00D9,
+            "Uacute": 0x00DA,
+            "Ucirc": 0x00DB,
+            "Uuml": 0x00DC,
+            "Yacute": 0x00DD,
+            "THORN": 0x00DE,
+            "szlig": 0x00DF,
+            "agrave": 0x00E0,
+            "aacute": 0x00E1,
+            "acirc": 0x00E2,
+            "atilde": 0x00E3,
+            "auml": 0x00E4,
+            "aring": 0x00E5,
+            "aelig": 0x00E6,
+            "ccedil": 0x00E7,
+            "egrave": 0x00E8,
+            "eacute": 0x00E9,
+            "ecirc": 0x00EA,
+            "euml": 0x00EB,
+            "igrave": 0x00EC,
+            "iacute": 0x00ED,
+            "icirc": 0x00EE,
+            "iuml": 0x00EF,
+            "eth": 0x00F0,
+            "ntilde": 0x00F1,
+            "ograve": 0x00F2,
+            "oacute": 0x00F3,
+            "ocirc": 0x00F4,
+            "otilde": 0x00F5,
+            "ouml": 0x00F6,
+            "divide": 0x00F7,
+            "oslash": 0x00F8,
+            "ugrave": 0x00F9,
+            "uacute": 0x00FA,
+            "ucirc": 0x00FB,
+            "uuml": 0x00FC,
+            "yacute": 0x00FD,
+            "thorn": 0x00FE,
+            "yuml": 0x00FF,
+            "OElig": 0x0152,
+            "oelig": 0x0153,
+            "Scaron": 0x0160,
+            "scaron": 0x0161,
+            "Yuml": 0x0178,
+            "fnof": 0x0192,
+            "circ": 0x02C6,
+            "tilde": 0x02DC,
+            "Alpha": 0x0391,
+            "Beta": 0x0392,
+            "Gamma": 0x0393,
+            "Delta": 0x0394,
+            "Epsilon": 0x0395,
+            "Zeta": 0x0396,
+            "Eta": 0x0397,
+            "Theta": 0x0398,
+            "Iota": 0x0399,
+            "Kappa": 0x039A,
+            "Lambda": 0x039B,
+            "Mu": 0x039C,
+            "Nu": 0x039D,
+            "Xi": 0x039E,
+            "Omicron": 0x039F,
+            "Pi": 0x03A0,
+            "Rho": 0x03A1,
+            "Sigma": 0x03A3,
+            "Tau": 0x03A4,
+            "Upsilon": 0x03A5,
+            "Phi": 0x03A6,
+            "Chi": 0x03A7,
+            "Psi": 0x03A8,
+            "Omega": 0x03A9,
+            "alpha": 0x03B1,
+            "beta": 0x03B2,
+            "gamma": 0x03B3,
+            "delta": 0x03B4,
+            "epsilon": 0x03B5,
+            "zeta": 0x03B6,
+            "eta": 0x03B7,
+            "theta": 0x03B8,
+            "iota": 0x03B9,
+            "kappa": 0x03BA,
+            "lambda": 0x03BB,
+            "mu": 0x03BC,
+            "nu": 0x03BD,
+            "xi": 0x03BE,
+            "omicron": 0x03BF,
+            "pi": 0x03C0,
+            "rho": 0x03C1,
+            "sigmaf": 0x03C2,
+            "sigma": 0x03C3,
+            "tau": 0x03C4,
+            "upsilon": 0x03C5,
+            "phi": 0x03C6,
+            "chi": 0x03C7,
+            "psi": 0x03C8,
+            "omega": 0x03C9,
+            "thetasym": 0x03D1,
+            "upsih": 0x03D2,
+            "piv": 0x03D6,
+            "ensp": 0x2002,
+            "emsp": 0x2003,
+            "thinsp": 0x2009,
+            "zwnj": 0x200C,
+            "zwj": 0x200D,
+            "lrm": 0x200E,
+            "rlm": 0x200F,
+            "ndash": 0x2013,
+            "mdash": 0x2014,
+            "lsquo": 0x2018,
+            "rsquo": 0x2019,
+            "sbquo": 0x201A,
+            "ldquo": 0x201C,
+            "rdquo": 0x201D,
+            "bdquo": 0x201E,
+            "dagger": 0x2020,
+            "Dagger": 0x2021,
+            "bull": 0x2022,
+            "hellip": 0x2026,
+            "permil": 0x2030,
+            "prime": 0x2032,
+            "Prime": 0x2033,
+            "lsaquo": 0x2039,
+            "rsaquo": 0x203A,
+            "oline": 0x203E,
+            "frasl": 0x2044,
+            "euro": 0x20AC,
+            "image": 0x2111,
+            "weierp": 0x2118,
+            "real": 0x211C,
+            "trade": 0x2122,
+            "alefsym": 0x2135,
+            "larr": 0x2190,
+            "uarr": 0x2191,
+            "rarr": 0x2192,
+            "darr": 0x2193,
+            "harr": 0x2194,
+            "crarr": 0x21B5,
+            "lArr": 0x21D0,
+            "uArr": 0x21D1,
+            "rArr": 0x21D2,
+            "dArr": 0x21D3,
+            "hArr": 0x21D4,
+            "forall": 0x2200,
+            "part": 0x2202,
+            "exist": 0x2203,
+            "empty": 0x2205,
+            "nabla": 0x2207,
+            "isin": 0x2208,
+            "notin": 0x2209,
+            "ni": 0x220B,
+            "prod": 0x220F,
+            "sum": 0x2211,
+            "minus": 0x2212,
+            "lowast": 0x2217,
+            "radic": 0x221A,
+            "prop": 0x221D,
+            "infin": 0x221E,
+            "ang": 0x2220,
+            "and": 0x2227,
+            "or": 0x2228,
+            "cap": 0x2229,
+            "cup": 0x222A,
+            "int": 0x222B,
+            "there4": 0x2234,
+            "sim": 0x223C,
+            "cong": 0x2245,
+            "asymp": 0x2248,
+            "ne": 0x2260,
+            "equiv": 0x2261,
+            "le": 0x2264,
+            "ge": 0x2265,
+            "sub": 0x2282,
+            "sup": 0x2283,
+            "nsub": 0x2284,
+            "sube": 0x2286,
+            "supe": 0x2287,
+            "oplus": 0x2295,
+            "otimes": 0x2297,
+            "perp": 0x22A5,
+            "sdot": 0x22C5,
+            "lceil": 0x2308,
+            "rceil": 0x2309,
+            "lfloor": 0x230A,
+            "rfloor": 0x230B,
+            "lang": 0x2329,
+            "rang": 0x232A,
+            "loz": 0x25CA,
+            "spades": 0x2660,
+            "clubs": 0x2663,
+            "hearts": 0x2665,
+            "diams": 0x2666
+        });
+    }
+}

src/compiler/transformers/module/es2015.ts

@@ -0,0 +1,43 @@
+/// <reference path="../../factory.ts" />
+/// <reference path="../../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    export function transformES2015Module(context: TransformationContext) {
+        const compilerOptions = context.getCompilerOptions();
+        return transformSourceFile;
+
+        function transformSourceFile(node: SourceFile) {
+            if (isDeclarationFile(node)) {
+                return node;
+            }
+
+            if (isExternalModule(node) || compilerOptions.isolatedModules) {
+                return visitEachChild(node, visitor, context);
+            }
+
+            return node;
+        }
+
+        function visitor(node: Node): VisitResult<Node> {
+            switch (node.kind) {
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                case SyntaxKind.ExportAssignment:
+                    return visitExportAssignment(<ExportAssignment>node);
+            }
+
+            return node;
+        }
+
+        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): VisitResult<ImportEqualsDeclaration> {
+            // Elide `import=` as it is not legal with --module ES6
+            return undefined;
+        }
+
+        function visitExportAssignment(node: ExportAssignment): VisitResult<ExportAssignment> {
+            // Elide `export=` as it is not legal with --module ES6
+            return node.isExportEquals ? undefined : node;
+        }
+    }
+}

src/compiler/tsc.ts

@@ -6,6 +6,11 @@ namespace ts {
         fileWatcher?: FileWatcher;
     }
 
+    interface Statistic {
+        name: string;
+        value: string;
+    }
+
     const defaultFormatDiagnosticsHost: FormatDiagnosticsHost = {
         getCurrentDirectory: () => sys.getCurrentDirectory(),
         getNewLine: () => sys.newLine,
@@ -230,18 +235,6 @@ namespace ts {
         return s;
     }
 
-    function reportStatisticalValue(name: string, value: string) {
-        sys.write(padRight(name + ":", 12) + padLeft(value.toString(), 10) + sys.newLine);
-    }
-
-    function reportCountStatistic(name: string, count: number) {
-        reportStatisticalValue(name, "" + count);
-    }
-
-    function reportTimeStatistic(name: string, time: number) {
-        reportStatisticalValue(name, (time / 1000).toFixed(2) + "s");
-    }
-
     function isJSONSupported() {
         return typeof JSON === "object" && typeof JSON.parse === "function";
     }
@@ -489,10 +482,7 @@ namespace ts {
             sourceFile.fileWatcher.close();
             sourceFile.fileWatcher = undefined;
             if (removed) {
-                const index = rootFileNames.indexOf(sourceFile.fileName);
-                if (index >= 0) {
-                    rootFileNames.splice(index, 1);
-                }
+                unorderedRemoveItem(rootFileNames, sourceFile.fileName);
             }
             startTimerForRecompilation();
         }
@@ -550,7 +540,11 @@ namespace ts {
 
     function compile(fileNames: string[], compilerOptions: CompilerOptions, compilerHost: CompilerHost) {
         const hasDiagnostics = compilerOptions.diagnostics || compilerOptions.extendedDiagnostics;
-        if (hasDiagnostics) performance.enable();
+        let statistics: Statistic[];
+        if (hasDiagnostics) {
+            performance.enable();
+            statistics = [];
+        }
 
         const program = createProgram(fileNames, compilerOptions, compilerHost);
         const exitStatus = compileProgram();
@@ -594,6 +588,7 @@ namespace ts {
                 reportTimeStatistic("Emit time", emitTime);
             }
             reportTimeStatistic("Total time", programTime + bindTime + checkTime + emitTime);
+            reportStatistics();
 
             performance.disable();
         }
@@ -635,6 +630,36 @@ namespace ts {
             }
             return ExitStatus.Success;
         }
+
+        function reportStatistics() {
+            let nameSize = 0;
+            let valueSize = 0;
+            for (const { name, value } of statistics) {
+                if (name.length > nameSize) {
+                    nameSize = name.length;
+                }
+
+                if (value.length > valueSize) {
+                    valueSize = value.length;
+                }
+            }
+
+            for (const { name, value } of statistics) {
+                sys.write(padRight(name + ":", nameSize + 2) + padLeft(value.toString(), valueSize) + sys.newLine);
+            }
+        }
+
+        function reportStatisticalValue(name: string, value: string) {
+            statistics.push({ name, value });
+        }
+
+        function reportCountStatistic(name: string, count: number) {
+            reportStatisticalValue(name, "" + count);
+        }
+
+        function reportTimeStatistic(name: string, time: number) {
+            reportStatisticalValue(name, (time / 1000).toFixed(2) + "s");
+        }
     }
 
     function printVersion() {
@@ -642,7 +667,7 @@ namespace ts {
     }
 
     function printHelp() {
-        let output = "";
+        const output: string[] = [];
 
         // We want to align our "syntax" and "examples" commands to a certain margin.
         const syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length;
@@ -653,17 +678,17 @@ namespace ts {
         let syntax = makePadding(marginLength - syntaxLength);
         syntax += "tsc [" + getDiagnosticText(Diagnostics.options) + "] [" + getDiagnosticText(Diagnostics.file) + " ...]";
 
-        output += getDiagnosticText(Diagnostics.Syntax_Colon_0, syntax);
-        output += sys.newLine + sys.newLine;
+        output.push(getDiagnosticText(Diagnostics.Syntax_Colon_0, syntax));
+        output.push(sys.newLine + sys.newLine);
 
         // Build up the list of examples.
         const padding = makePadding(marginLength);
-        output += getDiagnosticText(Diagnostics.Examples_Colon_0, makePadding(marginLength - examplesLength) + "tsc hello.ts") + sys.newLine;
-        output += padding + "tsc --outFile file.js file.ts" + sys.newLine;
-        output += padding + "tsc @args.txt" + sys.newLine;
-        output += sys.newLine;
+        output.push(getDiagnosticText(Diagnostics.Examples_Colon_0, makePadding(marginLength - examplesLength) + "tsc hello.ts") + sys.newLine);
+        output.push(padding + "tsc --outFile file.js file.ts" + sys.newLine);
+        output.push(padding + "tsc @args.txt" + sys.newLine);
+        output.push(sys.newLine);
 
-        output += getDiagnosticText(Diagnostics.Options_Colon) + sys.newLine;
+        output.push(getDiagnosticText(Diagnostics.Options_Colon) + sys.newLine);
 
         // Sort our options by their names, (e.g. "--noImplicitAny" comes before "--watch")
         const optsList = filter(optionDeclarations.slice(), v => !v.experimental);
@@ -730,18 +755,20 @@ namespace ts {
             const usage = usageColumn[i];
             const description = descriptionColumn[i];
             const kindsList = optionsDescriptionMap[description];
-            output += usage + makePadding(marginLength - usage.length + 2) + description + sys.newLine;
+            output.push(usage + makePadding(marginLength - usage.length + 2) + description + sys.newLine);
 
             if (kindsList) {
-                output += makePadding(marginLength + 4);
+                output.push(makePadding(marginLength + 4));
                 for (const kind of kindsList) {
-                    output += kind + " ";
+                    output.push(kind + " ");
                 }
-                output += sys.newLine;
+                output.push(sys.newLine);
             }
         }
 
-        sys.write(output);
+        for (const line of output) {
+            sys.write(line);
+        }
         return;
 
         function getParamType(option: CommandLineOption) {
@@ -771,4 +798,8 @@ namespace ts {
     }
 }
 
+if (ts.sys.tryEnableSourceMapsForHost && /^development$/i.test(ts.sys.getEnvironmentVariable("NODE_ENV"))) {
+    ts.sys.tryEnableSourceMapsForHost();
+}
+
 ts.executeCommandLine(ts.sys.args);

src/compiler/tsconfig.json

@@ -20,6 +20,20 @@
         "utilities.ts",
         "binder.ts",
         "checker.ts",
+        "factory.ts",
+        "visitor.ts",
+        "transformers/ts.ts",
+        "transformers/jsx.ts",
+        "transformers/es2017.ts",
+        "transformers/es2016.ts",
+        "transformers/es2015.ts",
+        "transformers/generators.ts",
+        "transformers/destructuring.ts",
+        "transformers/module/module.ts",
+        "transformers/module/system.ts",
+        "transformers/module/es2015.ts",
+        "transformer.ts",
+        "comments.ts",
         "sourcemap.ts",
         "declarationEmitter.ts",
         "emitter.ts",

src/harness/compilerRunner.ts

@@ -136,9 +136,7 @@ class CompilerBaselineRunner extends RunnerBase {
 
             // check errors
             it("Correct errors for " + fileName, () => {
-                if (this.errors) {
-                    Harness.Compiler.doErrorBaseline(justName, toBeCompiled.concat(otherFiles), result.errors);
-                }
+                 Harness.Compiler.doErrorBaseline(justName, toBeCompiled.concat(otherFiles), result.errors);
             });
 
             it (`Correct module resolution tracing for ${fileName}`, () => {
@@ -154,7 +152,7 @@ class CompilerBaselineRunner extends RunnerBase {
                 if (options.sourceMap || options.inlineSourceMap) {
                     Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
                         const record = result.getSourceMapRecord();
-                        if (options.noEmitOnError && result.errors.length !== 0 && record === undefined) {
+                        if ((options.noEmitOnError && result.errors.length !== 0) || record === undefined) {
                             // Because of the noEmitOnError option no files are created. We need to return null because baselining isn't required.
                             /* tslint:disable:no-null-keyword */
                             return null;

src/harness/harness.ts

@@ -374,7 +374,7 @@ namespace Utils {
         // call this on both nodes to ensure all propagated flags have been set (and thus can be
         // compared).
         assert.equal(ts.containsParseError(node1), ts.containsParseError(node2));
-        assert.equal(node1.flags, node2.flags, "node1.flags !== node2.flags");
+        assert.equal(node1.flags & ~ts.NodeFlags.ReachabilityAndEmitFlags, node2.flags & ~ts.NodeFlags.ReachabilityAndEmitFlags, "node1.flags !== node2.flags");
 
         ts.forEachChild(node1,
             child1 => {
@@ -416,6 +416,60 @@ namespace Utils {
 
         throw new Error("Could not find child in parent");
     }
+
+    const maxHarnessFrames = 1;
+
+    export function filterStack(error: Error, stackTraceLimit: number = Infinity) {
+        const stack = <string>(<any>error).stack;
+        if (stack) {
+            const lines = stack.split(/\r\n?|\n/g);
+            const filtered: string[] = [];
+            let frameCount = 0;
+            let harnessFrameCount = 0;
+            for (let line of lines) {
+                if (isStackFrame(line)) {
+                    if (frameCount >= stackTraceLimit
+                        || isMocha(line)
+                        || isNode(line)) {
+                        continue;
+                    }
+
+                    if (isHarness(line)) {
+                        if (harnessFrameCount >= maxHarnessFrames) {
+                            continue;
+                        }
+
+                        harnessFrameCount++;
+                    }
+
+                    line = line.replace(/\bfile:\/\/\/(.*?)(?=(:\d+)*($|\)))/, (_, path) => ts.sys.resolvePath(path));
+                    frameCount++;
+                }
+
+                filtered.push(line);
+            }
+
+            (<any>error).stack = filtered.join(Harness.IO.newLine());
+        }
+
+        return error;
+    }
+
+    function isStackFrame(line: string) {
+        return /^\s+at\s/.test(line);
+    }
+
+    function isMocha(line: string) {
+        return /[\\/](node_modules|components)[\\/]mocha(js)?[\\/]|[\\/]mocha\.js/.test(line);
+    }
+
+    function isNode(line: string) {
+        return /\((timers|events|node|module)\.js:/.test(line);
+    }
+
+    function isHarness(line: string) {
+        return /[\\/]src[\\/]harness[\\/]|[\\/]run\.js/.test(line);
+    }
 }
 
 namespace Harness.Path {
@@ -452,12 +506,17 @@ namespace Harness {
         getExecutingFilePath(): string;
         exit(exitCode?: number): void;
         readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[]): string[];
+        tryEnableSourceMapsForHost?(): void;
+        getEnvironmentVariable?(name: string): string;
     }
-    export var IO: IO;
+    export let IO: IO;
 
     // harness always uses one kind of new line
     const harnessNewLine = "\r\n";
 
+    // Root for file paths that are stored in a virtual file system
+    export const virtualFileSystemRoot = "/";
+
     namespace IOImpl {
         declare class Enumerator {
             public atEnd(): boolean;
@@ -490,6 +549,7 @@ namespace Harness {
             export const directoryExists: typeof IO.directoryExists = fso.FolderExists;
             export const fileExists: typeof IO.fileExists = fso.FileExists;
             export const log: typeof IO.log = global.WScript && global.WScript.StdOut.WriteLine;
+            export const getEnvironmentVariable: typeof IO.getEnvironmentVariable = name => ts.sys.getEnvironmentVariable(name);
             export const readDirectory: typeof IO.readDirectory = (path, extension, exclude, include) => ts.sys.readDirectory(path, extension, exclude, include);
 
             export function createDirectory(path: string) {
@@ -559,7 +619,13 @@ namespace Harness {
             export const writeFile: typeof IO.writeFile = (path, content) => ts.sys.writeFile(path, content);
             export const fileExists: typeof IO.fileExists = fs.existsSync;
             export const log: typeof IO.log = s => console.log(s);
+            export const getEnvironmentVariable: typeof IO.getEnvironmentVariable = name => ts.sys.getEnvironmentVariable(name);
 
+            export function tryEnableSourceMapsForHost() {
+                if (ts.sys.tryEnableSourceMapsForHost) {
+                    ts.sys.tryEnableSourceMapsForHost();
+                }
+            }
             export const readDirectory: typeof IO.readDirectory = (path, extension, exclude, include) => ts.sys.readDirectory(path, extension, exclude, include);
 
             export function createDirectory(path: string) {
@@ -710,7 +776,16 @@ namespace Harness {
                 return dirPath;
             }
             export let directoryName: typeof IO.directoryName = Utils.memoize(directoryNameImpl);
-            export const resolvePath = (path: string) => directoryName(path);
+
+            export function resolvePath(path: string) {
+                const response = Http.getFileFromServerSync(serverRoot + path + "?resolve=true");
+                if (response.status === 200) {
+                    return response.responseText;
+                }
+                else {
+                    return undefined;
+                }
+            }
 
             export function fileExists(path: string): boolean {
                 const response = Http.getFileFromServerSync(serverRoot + path);
@@ -784,7 +859,9 @@ namespace Harness {
 namespace Harness {
     export const libFolder = "built/local/";
     const tcServicesFileName = ts.combinePaths(libFolder, Utils.getExecutionEnvironment() === Utils.ExecutionEnvironment.Browser ? "typescriptServicesInBrowserTest.js" : "typescriptServices.js");
-    export const tcServicesFile = IO.readFile(tcServicesFileName);
+    export const tcServicesFile = IO.readFile(tcServicesFileName) + (Utils.getExecutionEnvironment() !== Utils.ExecutionEnvironment.Browser
+        ? IO.newLine() + `//# sourceURL=${IO.resolvePath(tcServicesFileName)}`
+        : "");
 
     export interface SourceMapEmitterCallback {
         (emittedFile: string, emittedLine: number, emittedColumn: number, sourceFile: string, sourceLine: number, sourceColumn: number, sourceName: string): void;
@@ -848,7 +925,7 @@ namespace Harness {
         export const defaultLibFileName = "lib.d.ts";
         export const es2015DefaultLibFileName = "lib.es2015.d.ts";
 
-        const libFileNameSourceFileMap=  ts.createMap<ts.SourceFile>({
+        const libFileNameSourceFileMap = ts.createMap<ts.SourceFile>({
             [defaultLibFileName]: createSourceFileAndAssertInvariants(defaultLibFileName, IO.readFile(libFolder + "lib.es5.d.ts"), /*languageVersion*/ ts.ScriptTarget.Latest)
         });
 
@@ -864,7 +941,17 @@ namespace Harness {
         }
 
         export function getDefaultLibFileName(options: ts.CompilerOptions): string {
-            return options.target === ts.ScriptTarget.ES6 ? es2015DefaultLibFileName : defaultLibFileName;
+            switch (options.target) {
+                case ts.ScriptTarget.ES2017:
+                    return "lib.es2017.d.ts";
+                case ts.ScriptTarget.ES2016:
+                    return "lib.es2016.d.ts";
+                case ts.ScriptTarget.ES2015:
+                    return es2015DefaultLibFileName;
+
+                default:
+                    return defaultLibFileName;
+            }
         }
 
         // Cache these between executions so we don't have to re-parse them for every test
@@ -1330,7 +1417,7 @@ namespace Harness {
 
         export function doErrorBaseline(baselinePath: string, inputFiles: TestFile[], errors: ts.Diagnostic[]) {
             Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?$/, ".errors.txt"), (): string => {
-                if (errors.length === 0) {
+                if (!errors || (errors.length === 0)) {
                     /* tslint:disable:no-null-keyword */
                     return null;
                     /* tslint:enable:no-null-keyword */
@@ -1370,23 +1457,31 @@ namespace Harness {
 
             // Produce baselines.  The first gives the types for all expressions.
             // The second gives symbols for all identifiers.
-            let e1: Error, e2: Error;
+            let typesError: Error, symbolsError: Error;
             try {
                 checkBaseLines(/*isSymbolBaseLine*/ false);
             }
             catch (e) {
-                e1 = e;
+                typesError = e;
             }
 
             try {
                 checkBaseLines(/*isSymbolBaseLine*/ true);
             }
             catch (e) {
-                e2 = e;
+                symbolsError = e;
             }
 
-            if (e1 || e2) {
-                throw e1 || e2;
+            if (typesError && symbolsError) {
+                throw new Error(typesError.message + ts.sys.newLine + symbolsError.message);
+            }
+
+            if (typesError) {
+                throw typesError;
+            }
+
+            if (symbolsError) {
+                throw symbolsError;
             }
 
             return;
@@ -1396,7 +1491,12 @@ namespace Harness {
 
                 const fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
 
-                Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?/, fullExtension), () => fullBaseLine, opts);
+                // When calling this function from rwc-runner, the baselinePath will have no extension.
+                // As rwc test- file is stored in json which ".json" will get stripped off.
+                // When calling this function from compiler-runner, the baselinePath will then has either ".ts" or ".tsx" extension
+                const outputFileName = ts.endsWith(baselinePath, ".ts") || ts.endsWith(baselinePath, ".tsx") ?
+                    baselinePath.replace(/\.tsx?/, fullExtension) : baselinePath.concat(fullExtension);
+                Harness.Baseline.runBaseline(outputFileName, () => fullBaseLine, opts);
             }
 
             function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
@@ -1468,7 +1568,7 @@ namespace Harness {
                 }
 
                 Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?/, ".js.map"), () => {
-                    if (options.noEmitOnError && result.errors.length !== 0 && result.sourceMaps.length === 0) {
+                    if ((options.noEmitOnError && result.errors.length !== 0) || result.sourceMaps.length === 0) {
                         // We need to return null here or the runBaseLine will actually create a empty file.
                         // Baselining isn't required here because there is no output.
                         /* tslint:disable:no-null-keyword */
@@ -1544,7 +1644,7 @@ namespace Harness {
 
         export function collateOutputs(outputFiles: Harness.Compiler.GeneratedFile[]): string {
             // Collect, test, and sort the fileNames
-            outputFiles.sort((a, b) => cleanName(a.fileName).localeCompare(cleanName(b.fileName)));
+            outputFiles.sort((a, b) => ts.compareStrings(cleanName(a.fileName), cleanName(b.fileName)));
 
             // Emit them
             let result = "";
@@ -1635,7 +1735,7 @@ namespace Harness {
             }
 
             public getSourceMapRecord() {
-                if (this.sourceMapData) {
+                if (this.sourceMapData && this.sourceMapData.length > 0) {
                     return Harness.SourceMapRecorder.getSourceMapRecord(this.sourceMapData, this.program, this.files);
                 }
             }
@@ -1754,7 +1854,8 @@ namespace Harness {
             const parseConfigHost: ts.ParseConfigHost = {
                 useCaseSensitiveFileNames: false,
                 readDirectory: (name) => [],
-                fileExists: (name) => true
+                fileExists: (name) => true,
+                readFile: (name) => ts.forEach(testUnitData, data => data.name.toLowerCase() === name.toLowerCase() ? data.content : undefined)
             };
 
             // check if project has tsconfig.json in the list of files
@@ -1772,7 +1873,7 @@ namespace Harness {
                     tsConfig.options.configFilePath = data.name;
 
                     // delete entry from the list
-                    testUnitData.splice(i, 1);
+                    ts.orderedRemoveItemAt(testUnitData, i);
 
                     break;
                 }
@@ -1892,9 +1993,7 @@ namespace Harness {
         }
 
         export function runBaseline(relativeFileName: string, generateContent: () => string, opts?: BaselineOptions): void {
-
             const actualFileName = localPath(relativeFileName, opts && opts.Baselinefolder, opts && opts.Subfolder);
-
             const actual = generateActual(generateContent);
             const comparison = compareToBaseline(actual, relativeFileName, opts);
             writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName);

src/harness/harnessLanguageService.ts

@@ -123,7 +123,7 @@ namespace Harness.LanguageService {
     }
 
     export class LanguageServiceAdapterHost {
-        protected fileNameToScript = ts.createMap<ScriptInfo>();
+        protected virtualFileSystem: Utils.VirtualFileSystem = new Utils.VirtualFileSystem(virtualFileSystemRoot, /*useCaseSensitiveFilenames*/false);
 
         constructor(protected cancellationToken = DefaultHostCancellationToken.Instance,
                     protected settings = ts.getDefaultCompilerOptions()) {
@@ -135,22 +135,24 @@ namespace Harness.LanguageService {
 
         public getFilenames(): string[] {
             const fileNames: string[] = [];
-            ts.forEachProperty(this.fileNameToScript, (scriptInfo) => {
+            for (const virtualEntry of this.virtualFileSystem.getAllFileEntries()){
+                const scriptInfo = virtualEntry.content;
                 if (scriptInfo.isRootFile) {
                     // only include root files here
                     // usually it means that we won't include lib.d.ts in the list of root files so it won't mess the computation of compilation root dir.
                     fileNames.push(scriptInfo.fileName);
                 }
-            });
+            }
             return fileNames;
         }
 
         public getScriptInfo(fileName: string): ScriptInfo {
-            return this.fileNameToScript[fileName];
+            const fileEntry = this.virtualFileSystem.traversePath(fileName);
+            return fileEntry && fileEntry.isFile() ? (<Utils.VirtualFile>fileEntry).content : undefined;
         }
 
         public addScript(fileName: string, content: string, isRootFile: boolean): void {
-            this.fileNameToScript[fileName] = new ScriptInfo(fileName, content, isRootFile);
+            this.virtualFileSystem.addFile(fileName, new ScriptInfo(fileName, content, isRootFile));
         }
 
         public editScript(fileName: string, start: number, end: number, newText: string) {
@@ -171,7 +173,7 @@ namespace Harness.LanguageService {
           * @param col 0 based index
           */
         public positionToLineAndCharacter(fileName: string, position: number): ts.LineAndCharacter {
-            const script: ScriptInfo = this.fileNameToScript[fileName];
+            const script: ScriptInfo = this.getScriptInfo(fileName);
             assert.isOk(script);
 
             return ts.computeLineAndCharacterOfPosition(script.getLineMap(), position);
@@ -182,8 +184,14 @@ namespace Harness.LanguageService {
     class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost {
         getCompilationSettings() { return this.settings; }
         getCancellationToken() { return this.cancellationToken; }
-        getDirectories(path: string): string[] { return []; }
-        getCurrentDirectory(): string { return ""; }
+        getDirectories(path: string): string[] {
+            const dir = this.virtualFileSystem.traversePath(path);
+            if (dir && dir.isDirectory()) {
+                return ts.map((<Utils.VirtualDirectory>dir).getDirectories(), (d) => ts.combinePaths(path, d.name));
+            }
+            return [];
+        }
+        getCurrentDirectory(): string { return virtualFileSystemRoot; }
         getDefaultLibFileName(): string { return Harness.Compiler.defaultLibFileName; }
         getScriptFileNames(): string[] { return this.getFilenames(); }
         getScriptSnapshot(fileName: string): ts.IScriptSnapshot {
@@ -196,6 +204,25 @@ namespace Harness.LanguageService {
             return script ? script.version.toString() : undefined;
         }
 
+        fileExists(fileName: string): boolean {
+            const script = this.getScriptSnapshot(fileName);
+            return script !== undefined;
+        }
+        readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[] {
+            return ts.matchFiles(path, extensions, exclude, include,
+            /*useCaseSensitiveFileNames*/false,
+            this.getCurrentDirectory(),
+            (p) => this.virtualFileSystem.getAccessibleFileSystemEntries(p));
+        }
+        readFile(path: string, encoding?: string): string {
+            const snapshot = this.getScriptSnapshot(path);
+            return snapshot.getText(0, snapshot.getLength());
+        }
+        getTypeRootsVersion() {
+            return 0;
+        }
+
+
         log(s: string): void { }
         trace(s: string): void { }
         error(s: string): void { }
@@ -384,6 +411,9 @@ namespace Harness.LanguageService {
         getCompletionEntryDetails(fileName: string, position: number, entryName: string): ts.CompletionEntryDetails {
             return unwrapJSONCallResult(this.shim.getCompletionEntryDetails(fileName, position, entryName));
         }
+        getCompletionEntrySymbol(fileName: string, position: number, entryName: string): ts.Symbol {
+            throw new Error("getCompletionEntrySymbol not implemented across the shim layer.");
+        }
         getQuickInfoAtPosition(fileName: string, position: number): ts.QuickInfo {
             return unwrapJSONCallResult(this.shim.getQuickInfoAtPosition(fileName, position));
         }
@@ -408,6 +438,9 @@ namespace Harness.LanguageService {
         getTypeDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[] {
             return unwrapJSONCallResult(this.shim.getTypeDefinitionAtPosition(fileName, position));
         }
+        getImplementationAtPosition(fileName: string, position: number): ts.ImplementationLocation[] {
+            return unwrapJSONCallResult(this.shim.getImplementationAtPosition(fileName, position));
+        }
         getReferencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] {
             return unwrapJSONCallResult(this.shim.getReferencesAtPosition(fileName, position));
         }
@@ -426,6 +459,10 @@ namespace Harness.LanguageService {
         getNavigationBarItems(fileName: string): ts.NavigationBarItem[] {
             return unwrapJSONCallResult(this.shim.getNavigationBarItems(fileName));
         }
+        getNavigationTree(fileName: string): ts.NavigationTree {
+            return unwrapJSONCallResult(this.shim.getNavigationTree(fileName));
+        }
+
         getOutliningSpans(fileName: string): ts.OutliningSpan[] {
             return unwrapJSONCallResult(this.shim.getOutliningSpans(fileName));
         }
@@ -453,6 +490,9 @@ namespace Harness.LanguageService {
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean {
             return unwrapJSONCallResult(this.shim.isValidBraceCompletionAtPosition(fileName, position, openingBrace));
         }
+        getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[]): ts.CodeAction[] {
+            throw new Error("Not supported on the shim.");
+        }
         getEmitOutput(fileName: string): ts.EmitOutput {
             return unwrapJSONCallResult(this.shim.getEmitOutput(fileName));
         }
@@ -462,6 +502,9 @@ namespace Harness.LanguageService {
         getNonBoundSourceFile(fileName: string): ts.SourceFile {
             throw new Error("SourceFile can not be marshaled across the shim layer.");
         }
+        getSourceFile(fileName: string): ts.SourceFile {
+            throw new Error("SourceFile can not be marshaled across the shim layer.");
+        }
         dispose(): void { this.shim.dispose({}); }
     }
 
@@ -572,7 +615,6 @@ namespace Harness.LanguageService {
             this.writeMessage(message);
         }
 
-
         readFile(fileName: string): string {
             if (fileName.indexOf(Harness.Compiler.defaultLibFileName) >= 0) {
                 fileName = Harness.Compiler.defaultLibFileName;
@@ -617,6 +659,10 @@ namespace Harness.LanguageService {
             return [];
         }
 
+        getEnvironmentVariable(name: string): string {
+            return ts.sys.getEnvironmentVariable(name);
+        }
+
         readDirectory(path: string, extension?: string[], exclude?: string[], include?: string[]): string[] {
             throw new Error("Not implemented Yet.");
         }
@@ -644,7 +690,11 @@ namespace Harness.LanguageService {
             return true;
         }
 
-        isVerbose() {
+        getLogFileName(): string {
+            return undefined;
+        }
+
+        hasLevel() {
             return false;
         }
 
@@ -666,6 +716,14 @@ namespace Harness.LanguageService {
         clearTimeout(timeoutId: any): void {
             clearTimeout(timeoutId);
         }
+
+        setImmediate(callback: (...args: any[]) => void, ms: number, ...args: any[]): any {
+            return setImmediate(callback, args);
+        }
+
+        clearImmediate(timeoutId: any): void {
+            clearImmediate(timeoutId);
+        }
     }
 
     export class ServerLanguageServiceAdapter implements LanguageServiceAdapter {
@@ -680,8 +738,12 @@ namespace Harness.LanguageService {
             // host to answer server queries about files on disk
             const serverHost = new SessionServerHost(clientHost);
             const server = new ts.server.Session(serverHost,
-                Buffer ? Buffer.byteLength : (string: string, encoding?: string) => string.length,
-                process.hrtime, serverHost);
+                { isCancellationRequested: () => false },
+                /*useOneInferredProject*/ false,
+                /*typingsInstaller*/ undefined,
+                Utils.byteLength,
+                process.hrtime, serverHost,
+                /*canUseEvents*/ true);
 
             // Fake the connection between the client and the server
             serverHost.writeMessage = client.onMessage.bind(client);

src/harness/loggedIO.ts

@@ -1,6 +1,8 @@
 /// <reference path="..\..\src\compiler\sys.ts" />
 /// <reference path="..\..\src\harness\harness.ts" />
+/// <reference path="..\..\src\harness\harnessLanguageService.ts" />
 /// <reference path="..\..\src\harness\runnerbase.ts" />
+/// <reference path="..\..\src\harness\typeWriter.ts" />
 
 interface FileInformation {
     contents: string;

src/harness/projectsRunner.ts

@@ -222,6 +222,7 @@ class ProjectRunner extends RunnerBase {
                     useCaseSensitiveFileNames: Harness.IO.useCaseSensitiveFileNames(),
                     fileExists,
                     readDirectory,
+                    readFile
                 };
                 const configParseResult = ts.parseJsonConfigFileContent(configObject, configParseHost, ts.getDirectoryPath(configFileName), compilerOptions);
                 if (configParseResult.errors.length > 0) {
@@ -292,6 +293,10 @@ class ProjectRunner extends RunnerBase {
                 return Harness.IO.fileExists(getFileNameInTheProjectTest(fileName));
             }
 
+            function readFile(fileName: string): string {
+                return Harness.IO.readFile(getFileNameInTheProjectTest(fileName));
+            }
+
             function getSourceFileText(fileName: string): string {
                 let text: string = undefined;
                 try {
@@ -473,7 +478,6 @@ class ProjectRunner extends RunnerBase {
                         }
                     });
 
-
                     it("Baseline of emitted result (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                         if (testCase.baselineCheck) {
                             const errs: Error[] = [];
@@ -500,18 +504,16 @@ class ProjectRunner extends RunnerBase {
                         }
                     });
 
-
-                    it("SourceMapRecord for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
-                        if (compilerResult.sourceMapData) {
-                            Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".sourcemap.txt", () => {
-                                return Harness.SourceMapRecorder.getSourceMapRecord(compilerResult.sourceMapData, compilerResult.program,
-                                    ts.filter(compilerResult.outputFiles, outputFile => Harness.Compiler.isJS(outputFile.emittedFileName)));
-                            });
-                        }
-                    });
+                    // it("SourceMapRecord for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
+                    //     if (compilerResult.sourceMapData) {
+                    //         Harness.Baseline.runBaseline(getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".sourcemap.txt", () => {
+                    //             return Harness.SourceMapRecorder.getSourceMapRecord(compilerResult.sourceMapData, compilerResult.program,
+                    //                 ts.filter(compilerResult.outputFiles, outputFile => Harness.Compiler.isJS(outputFile.emittedFileName)));
+                    //         });
+                    //     }
+                    // });
 
                     // Verify that all the generated .d.ts files compile
-
                     it("Errors in generated Dts files for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                         if (!compilerResult.errors.length && testCase.declaration) {
                             const dTsCompileResult = compileCompileDTsFiles(compilerResult);

src/harness/runner.ts

@@ -82,6 +82,7 @@ interface TestConfig {
     light?: boolean;
     taskConfigsFolder?: string;
     workerCount?: number;
+    stackTraceLimit?: number | "full";
     tasks?: TaskSet[];
     test?: string[];
     runUnitTests?: boolean;
@@ -116,6 +117,13 @@ if (testConfigContent !== "") {
         }
     }
 
+    if (testConfig.stackTraceLimit === "full") {
+        (<any>Error).stackTraceLimit = Infinity;
+    }
+    else if ((+testConfig.stackTraceLimit | 0) > 0) {
+        (<any>Error).stackTraceLimit = testConfig.stackTraceLimit;
+    }
+
     if (testConfig.test && testConfig.test.length > 0) {
         for (const option of testConfig.test) {
             if (!option) {

src/harness/rwcRunner.ts

@@ -79,6 +79,7 @@ namespace RWC {
                             useCaseSensitiveFileNames: Harness.IO.useCaseSensitiveFileNames(),
                             fileExists: Harness.IO.fileExists,
                             readDirectory: Harness.IO.readDirectory,
+                            readFile: Harness.IO.readFile
                         };
                         const configParseResult = ts.parseJsonConfigFileContent(parsedTsconfigFileContents.config, configParseHost, ts.getDirectoryPath(tsconfigFile.path));
                         fileNames = configParseResult.fileNames;
@@ -158,13 +159,13 @@ namespace RWC {
 
 
             it("has the expected emitted code", () => {
-                Harness.Baseline.runBaseline(baseName + ".output.js", () => {
+                Harness.Baseline.runBaseline(`${baseName}.output.js`, () => {
                     return Harness.Compiler.collateOutputs(compilerResult.files);
                 }, baselineOpts);
             });
 
             it("has the expected declaration file content", () => {
-                Harness.Baseline.runBaseline(baseName + ".d.ts", () => {
+                Harness.Baseline.runBaseline(`${baseName}.d.ts`, () => {
                     if (!compilerResult.declFilesCode.length) {
                         return null;
                     }
@@ -174,7 +175,7 @@ namespace RWC {
             });
 
             it("has the expected source maps", () => {
-                Harness.Baseline.runBaseline(baseName + ".map", () => {
+                Harness.Baseline.runBaseline(`${baseName}.map`, () => {
                     if (!compilerResult.sourceMaps.length) {
                         return null;
                     }
@@ -192,7 +193,7 @@ namespace RWC {
             });*/
 
             it("has the expected errors", () => {
-                Harness.Baseline.runBaseline(baseName + ".errors.txt", () => {
+                Harness.Baseline.runBaseline(`${baseName}.errors.txt`, () => {
                     if (compilerResult.errors.length === 0) {
                         return null;
                     }
@@ -207,7 +208,7 @@ namespace RWC {
             // declaration file errors as part of the baseline.
             it("has the expected errors in generated declaration files", () => {
                 if (compilerOptions.declaration && !compilerResult.errors.length) {
-                    Harness.Baseline.runBaseline(baseName + ".dts.errors.txt", () => {
+                    Harness.Baseline.runBaseline(`${baseName}.dts.errors.txt`, () => {
                         const declFileCompilationResult = Harness.Compiler.compileDeclarationFiles(
                             inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
 
@@ -223,6 +224,7 @@ namespace RWC {
             });
 
             it("has the expected types", () => {
+                // We don't need to pass the extension here because "doTypeAndSymbolBaseline" will append appropriate extension of ".types" or ".symbols"
                 Harness.Compiler.doTypeAndSymbolBaseline(baseName, compilerResult, inputFiles
                     .concat(otherFiles)
                     .filter(file => !!compilerResult.program.getSourceFile(file.unitName))

src/harness/tsconfig.json

@@ -22,6 +22,20 @@
         "../compiler/utilities.ts",
         "../compiler/binder.ts",
         "../compiler/checker.ts",
+        "../compiler/factory.ts",
+        "../compiler/visitor.ts",
+        "../compiler/transformers/ts.ts",
+        "../compiler/transformers/jsx.ts",
+        "../compiler/transformers/es2017.ts",
+        "../compiler/transformers/es2016.ts",
+        "../compiler/transformers/es2015.ts",
+        "../compiler/transformers/generators.ts",
+        "../compiler/transformers/destructuring.ts",
+        "../compiler/transformers/module/module.ts",
+        "../compiler/transformers/module/system.ts",
+        "../compiler/transformers/module/es2015.ts",
+        "../compiler/transformer.ts",
+        "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
         "../compiler/emitter.ts",
@@ -86,10 +100,14 @@
         "./unittests/moduleResolution.ts",
         "./unittests/tsconfigParsing.ts",
         "./unittests/commandLineParsing.ts",
+        "./unittests/configurationExtension.ts",
         "./unittests/convertCompilerOptionsFromJson.ts",
         "./unittests/convertTypingOptionsFromJson.ts",
         "./unittests/tsserverProjectSystem.ts",
         "./unittests/matchFiles.ts",
-        "./unittests/initializeTSConfig.ts"
+        "./unittests/initializeTSConfig.ts",
+        "./unittests/compileOnSave.ts",
+        "./unittests/typingsInstaller.ts",
+        "./unittests/projectErrors.ts"
     ]
 }

src/harness/typeWriter.ts

@@ -29,7 +29,7 @@ class TypeWriterWalker {
     }
 
     private visitNode(node: ts.Node): void {
-        if (ts.isExpression(node) || node.kind === ts.SyntaxKind.Identifier) {
+        if (ts.isPartOfExpression(node) || node.kind === ts.SyntaxKind.Identifier) {
             this.logTypeAndSymbol(node);
         }
 

src/harness/unittests/cachingInServerLSHost.ts

@@ -47,6 +47,7 @@ namespace ts {
                 return "";
             },
             getDirectories: (path: string) => [],
+            getEnvironmentVariable: (name: string) => "",
             readDirectory: (path: string, extension?: string[], exclude?: string[], include?: string[]): string[] => {
                 throw new Error("NYI");
             },
@@ -63,26 +64,29 @@ namespace ts {
                 };
             },
             setTimeout,
-            clearTimeout
+            clearTimeout,
+            setImmediate,
+            clearImmediate
         };
     }
 
     function createProject(rootFile: string, serverHost: server.ServerHost): { project: server.Project, rootScriptInfo: server.ScriptInfo } {
         const logger: server.Logger = {
             close() { },
-            isVerbose: () => false,
+            hasLevel: () => false,
             loggingEnabled: () => false,
             perftrc: (s: string) => { },
             info: (s: string) => { },
             startGroup: () => { },
             endGroup: () => { },
-            msg: (s: string, type?: string) => { }
+            msg: (s: string, type?: string) => { },
+            getLogFileName: (): string => undefined
         };
 
-        const projectService = new server.ProjectService(serverHost, logger);
-        const rootScriptInfo = projectService.openFile(rootFile, /* openedByClient */true);
-        const project = projectService.createInferredProject(rootScriptInfo);
-        project.setProjectOptions({ files: [rootScriptInfo.fileName], compilerOptions: { module: ts.ModuleKind.AMD } });
+        const projectService = new server.ProjectService(serverHost, logger, { isCancellationRequested: () => false }, /*useOneInferredProject*/ false, /*typingsInstaller*/ undefined);
+        const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */true, /*containingProject*/ undefined);
+        const project = projectService.createInferredProjectWithRootFileIfNecessary(rootScriptInfo);
+        project.setCompilerOptions({ module: ts.ModuleKind.AMD } );
         return {
             project,
             rootScriptInfo
@@ -105,10 +109,9 @@ namespace ts {
             const { project, rootScriptInfo } = createProject(root.name, serverHost);
 
             // ensure that imported file was found
-            let diags = project.compilerService.languageService.getSemanticDiagnostics(imported.name);
+            let diags = project.getLanguageService().getSemanticDiagnostics(imported.name);
             assert.equal(diags.length, 1);
 
-            let content = rootScriptInfo.getText();
 
             const originalFileExists = serverHost.fileExists;
             {
@@ -120,10 +123,9 @@ namespace ts {
 
                 const newContent = `import {x} from "f1"
                 var x: string = 1;`;
-                rootScriptInfo.editContent(0, content.length, newContent);
-                content = newContent;
+                rootScriptInfo.editContent(0, root.content.length, newContent);
                 // trigger synchronization to make sure that import will be fetched from the cache
-                diags = project.compilerService.languageService.getSemanticDiagnostics(imported.name);
+                diags = project.getLanguageService().getSemanticDiagnostics(imported.name);
                 // ensure file has correct number of errors after edit
                 assert.equal(diags.length, 1);
             }
@@ -138,12 +140,11 @@ namespace ts {
                     return originalFileExists.call(serverHost, fileName);
                 };
                 const newContent = `import {x} from "f2"`;
-                rootScriptInfo.editContent(0, content.length, newContent);
-                content = newContent;
+                rootScriptInfo.editContent(0, root.content.length, newContent);
 
                 try {
                     // trigger synchronization to make sure that LSHost will try to find 'f2' module on disk
-                    project.compilerService.languageService.getSemanticDiagnostics(imported.name);
+                    project.getLanguageService().getSemanticDiagnostics(imported.name);
                     assert.isTrue(false, `should not find file '${imported.name}'`);
                 }
                 catch (e) {
@@ -164,20 +165,18 @@ namespace ts {
                 };
 
                 const newContent = `import {x} from "f1"`;
-                rootScriptInfo.editContent(0, content.length, newContent);
-                content = newContent;
-                project.compilerService.languageService.getSemanticDiagnostics(imported.name);
+                rootScriptInfo.editContent(0, root.content.length, newContent);
+                project.getLanguageService().getSemanticDiagnostics(imported.name);
                 assert.isTrue(fileExistsCalled);
 
                 // setting compiler options discards module resolution cache
                 fileExistsCalled = false;
 
-                const opts = ts.clone(project.projectOptions);
-                opts.compilerOptions = ts.clone(opts.compilerOptions);
-                opts.compilerOptions.target = ts.ScriptTarget.ES5;
-                project.setProjectOptions(opts);
+                const compilerOptions = ts.clone(project.getCompilerOptions());
+                compilerOptions.target = ts.ScriptTarget.ES5;
+                project.setCompilerOptions(compilerOptions);
 
-                project.compilerService.languageService.getSemanticDiagnostics(imported.name);
+                project.getLanguageService().getSemanticDiagnostics(imported.name);
                 assert.isTrue(fileExistsCalled);
             }
         });
@@ -210,8 +209,8 @@ namespace ts {
             };
 
             const { project, rootScriptInfo } = createProject(root.name, serverHost);
-            const content = rootScriptInfo.getText();
-            let diags = project.compilerService.languageService.getSemanticDiagnostics(root.name);
+
+            let diags = project.getLanguageService().getSemanticDiagnostics(root.name);
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called");
             assert.isTrue(diags.length === 1, "one diagnostic expected");
             assert.isTrue(typeof diags[0].messageText === "string" && ((<string>diags[0].messageText).indexOf("Cannot find module") === 0), "should be 'cannot find module' message");
@@ -219,9 +218,9 @@ namespace ts {
             // assert that import will success once file appear on disk
             fileMap[imported.name] = imported;
             fileExistsCalledForBar = false;
-            rootScriptInfo.editContent(0, content.length, `import {y} from "bar"`);
+            rootScriptInfo.editContent(0, root.content.length, `import {y} from "bar"`);
 
-            diags = project.compilerService.languageService.getSemanticDiagnostics(root.name);
+            diags = project.getLanguageService().getSemanticDiagnostics(root.name);
             assert.isTrue(fileExistsCalledForBar, "'fileExists' should be called");
             assert.isTrue(diags.length === 0);
         });

src/harness/unittests/commandLineParsing.ts

@@ -60,7 +60,7 @@ namespace ts {
             assertParseResult(["--lib", "es5,invalidOption", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 
@@ -165,7 +165,7 @@ namespace ts {
                         start: undefined,
                         length: undefined,
                     }, {
-                            messageText: "Argument for '--target' option must be:  'es3', 'es5', 'es6', 'es2015'",
+                            messageText: "Argument for '--target' option must be:  'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017'",
                             category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                             code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 
@@ -263,7 +263,7 @@ namespace ts {
             assertParseResult(["--lib", "es5,", "es7", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 
@@ -283,7 +283,7 @@ namespace ts {
             assertParseResult(["--lib", "es5, ", "es7", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         category: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: ts.Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
 

src/harness/unittests/compileOnSave.ts

@@ -0,0 +1,496 @@
+/// <reference path="../harness.ts" />
+/// <reference path="./tsserverProjectSystem.ts" />
+/// <reference path="../../server/typingsInstaller/typingsInstaller.ts" />
+
+namespace ts.projectSystem {
+    import CommandNames = server.CommandNames;
+
+    function createTestTypingsInstaller(host: server.ServerHost) {
+        return new TestTypingsInstaller("/a/data/", /*throttleLimit*/5, host);
+    }
+
+    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 actualResult = response.sort((list1, list2) => compareStrings(list1.projectFileName, list2.projectFileName));
+            expectedFileList = expectedFileList.sort((list1, list2) => compareStrings(list1.projectFileName, list2.projectFileName));
+
+            assert.equal(actualResult.length, expectedFileList.length, `Actual result project number is different from the expected project number`);
+
+            for (let i = 0; i < actualResult.length; i++) {
+                const actualResultSingleProject = actualResult[i];
+                const expectedResultSingleProject = expectedFileList[i];
+                assert.equal(actualResultSingleProject.projectFileName, expectedResultSingleProject.projectFileName, `Actual result contains different projects than the expected result`);
+
+                const actualResultSingleProjectFileNameList = actualResultSingleProject.fileNames.sort();
+                const expectedResultSingleProjectFileNameList = map(expectedResultSingleProject.files, f => f.path).sort();
+                assert.isTrue(
+                    arrayIsEqualTo(actualResultSingleProjectFileNameList, expectedResultSingleProjectFileNameList),
+                    `For project ${actualResultSingleProject.projectFileName}, the actual result is ${actualResultSingleProjectFileNameList}, while expected ${expectedResultSingleProjectFileNameList}`);
+            }
+        }
+
+        describe("for configured projects", () => {
+            let moduleFile1: FileOrFolder;
+            let file1Consumer1: FileOrFolder;
+            let file1Consumer2: FileOrFolder;
+            let moduleFile2: FileOrFolder;
+            let globalFile3: FileOrFolder;
+            let configFile: FileOrFolder;
+            let changeModuleFile1ShapeRequest1: server.protocol.Request;
+            let changeModuleFile1InternalRequest1: server.protocol.Request;
+            let changeModuleFile1ShapeRequest2: server.protocol.Request;
+            // A compile on save affected file request using file1
+            let moduleFile1FileListRequest: server.protocol.Request;
+
+            beforeEach(() => {
+                moduleFile1 = {
+                    path: "/a/b/moduleFile1.ts",
+                    content: "export function Foo() { };"
+                };
+
+                file1Consumer1 = {
+                    path: "/a/b/file1Consumer1.ts",
+                    content: `import {Foo} from "./moduleFile1"; export var y = 10;`
+                };
+
+                file1Consumer2 = {
+                    path: "/a/b/file1Consumer2.ts",
+                    content: `import {Foo} from "./moduleFile1"; let z = 10;`
+                };
+
+                moduleFile2 = {
+                    path: "/a/b/moduleFile2.ts",
+                    content: `export var Foo4 = 10;`
+                };
+
+                globalFile3 = {
+                    path: "/a/b/globalFile3.ts",
+                    content: `interface GlobalFoo { age: number }`
+                };
+
+                configFile = {
+                    path: "/a/b/tsconfig.json",
+                    content: `{
+                        "compileOnSave": true
+                    }`
+                };
+
+                // Change the content of file1 to `export var T: number;export function Foo() { };`
+                changeModuleFile1ShapeRequest1 = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 1,
+                    insertString: `export var T: number;`
+                });
+
+                // Change the content of file1 to `export var T: number;export function Foo() { };`
+                changeModuleFile1InternalRequest1 = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 1,
+                    insertString: `var T1: number;`
+                });
+
+                // Change the content of file1 to `export var T: number;export function Foo() { };`
+                changeModuleFile1ShapeRequest2 = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 1,
+                    insertString: `export var T2: number;`
+                });
+
+                moduleFile1FileListRequest = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: moduleFile1.path, projectFileName: configFile.path });
+            });
+
+            it("should contains only itself if a module file's shape didn't change, and all files referencing it if its shape changed", () => {
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1, file1Consumer1], session);
+
+                // Send an initial compileOnSave request
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+
+                // Change the content of file1 to `export var T: number;export function Foo() { console.log('hi'); };`
+                const changeFile1InternalRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 46,
+                    endLine: 1,
+                    endOffset: 46,
+                    insertString: `console.log('hi');`
+                });
+                session.executeCommand(changeFile1InternalRequest);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1] }]);
+            });
+
+            it("should be up-to-date with the reference map changes", () => {
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1, file1Consumer1], session);
+
+                // Send an initial compileOnSave request
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+
+                // Change file2 content to `let y = Foo();`
+                const removeFile1Consumer1ImportRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: file1Consumer1.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 28,
+                    insertString: ""
+                });
+                session.executeCommand(removeFile1Consumer1ImportRequest);
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer2] }]);
+
+                // Add the import statements back to file2
+                const addFile2ImportRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: file1Consumer1.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 1,
+                    insertString: `import {Foo} from "./moduleFile1";`
+                });
+                session.executeCommand(addFile2ImportRequest);
+
+                // Change the content of file1 to `export var T2: string;export var T: number;export function Foo() { };`
+                const changeModuleFile1ShapeRequest2 = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 1,
+                    insertString: `export var T2: string;`
+                });
+                session.executeCommand(changeModuleFile1ShapeRequest2);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+            });
+
+            it("should be up-to-date with changes made in non-open files", () => {
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1], session);
+
+                // Send an initial compileOnSave request
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+
+                file1Consumer1.content = `let y = 10;`;
+                host.reloadFS([moduleFile1, file1Consumer1, file1Consumer2, configFile, libFile]);
+                host.triggerFileWatcherCallback(file1Consumer1.path, /*removed*/ false);
+
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer2] }]);
+            });
+
+            it("should be up-to-date with deleted files", () => {
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1], session);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                // Delete file1Consumer2
+                host.reloadFS([moduleFile1, file1Consumer1, configFile, libFile]);
+                host.triggerFileWatcherCallback(file1Consumer2.path, /*removed*/ true);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1] }]);
+            });
+
+            it("should be up-to-date with newly created files", () => {
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1], session);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2] }]);
+
+                const file1Consumer3: FileOrFolder = {
+                    path: "/a/b/file1Consumer3.ts",
+                    content: `import {Foo} from "./moduleFile1"; let y = Foo();`
+                };
+                host.reloadFS([moduleFile1, file1Consumer1, file1Consumer2, file1Consumer3, globalFile3, configFile, libFile]);
+                host.triggerDirectoryWatcherCallback(ts.getDirectoryPath(file1Consumer3.path), file1Consumer3.path);
+                host.runQueuedTimeoutCallbacks();
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2, file1Consumer3] }]);
+            });
+
+            it("should detect changes in non-root files", () => {
+                moduleFile1 = {
+                    path: "/a/b/moduleFile1.ts",
+                    content: "export function Foo() { };"
+                };
+
+                file1Consumer1 = {
+                    path: "/a/b/file1Consumer1.ts",
+                    content: `import {Foo} from "./moduleFile1"; let y = Foo();`
+                };
+
+                configFile = {
+                    path: "/a/b/tsconfig.json",
+                    content: `{
+                        "compileOnSave": true,
+                        "files": ["${file1Consumer1.path}"]
+                    }`
+                };
+
+                const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1, file1Consumer1], session);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1] }]);
+
+                // change file1 shape now, and verify both files are affected
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1] }]);
+
+                // change file1 internal, and verify only file1 is affected
+                session.executeCommand(changeModuleFile1InternalRequest1);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1] }]);
+            });
+
+            it("should return all files if a global file changed shape", () => {
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([globalFile3], session);
+                const changeGlobalFile3ShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: globalFile3.path,
+                    line: 1,
+                    offset: 1,
+                    endLine: 1,
+                    endOffset: 1,
+                    insertString: `var T2: string;`
+                });
+
+                // check after file1 shape changes
+                session.executeCommand(changeGlobalFile3ShapeRequest);
+                const globalFile3FileListRequest = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: globalFile3.path });
+                sendAffectedFileRequestAndCheckResult(session, globalFile3FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer2, globalFile3, moduleFile2] }]);
+            });
+
+            it("should return empty array if CompileOnSave is not enabled", () => {
+                configFile = {
+                    path: "/a/b/tsconfig.json",
+                    content: `{}`
+                };
+
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer2, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                openFilesForSession([moduleFile1], session);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, []);
+            });
+
+            it("should always return the file itself if '--isolatedModules' is specified", () => {
+                configFile = {
+                    path: "/a/b/tsconfig.json",
+                    content: `{
+                        "compileOnSave": true,
+                        "compilerOptions": {
+                            "isolatedModules": true
+                        }
+                    }`
+                };
+
+                const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                openFilesForSession([moduleFile1], session);
+
+                const file1ChangeShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 27,
+                    endLine: 1,
+                    endOffset: 27,
+                    insertString: `Point,`
+                });
+                session.executeCommand(file1ChangeShapeRequest);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1] }]);
+            });
+
+            it("should always return the file itself if '--out' or '--outFile' is specified", () => {
+                configFile = {
+                    path: "/a/b/tsconfig.json",
+                    content: `{
+                        "compileOnSave": true,
+                        "compilerOptions": {
+                            "module": "system",
+                            "outFile": "/a/b/out.js"
+                        }
+                    }`
+                };
+
+                const host = createServerHost([moduleFile1, file1Consumer1, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+                openFilesForSession([moduleFile1], session);
+
+                const file1ChangeShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: moduleFile1.path,
+                    line: 1,
+                    offset: 27,
+                    endLine: 1,
+                    endOffset: 27,
+                    insertString: `Point,`
+                });
+                session.executeCommand(file1ChangeShapeRequest);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1] }]);
+            });
+
+            it("should return cascaded affected file list", () => {
+                const file1Consumer1Consumer1: FileOrFolder = {
+                    path: "/a/b/file1Consumer1Consumer1.ts",
+                    content: `import {y} from "./file1Consumer1";`
+                };
+                const host = createServerHost([moduleFile1, file1Consumer1, file1Consumer1Consumer1, globalFile3, configFile, libFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([moduleFile1, file1Consumer1], session);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer1Consumer1] }]);
+
+                const changeFile1Consumer1ShapeRequest = makeSessionRequest<server.protocol.ChangeRequestArgs>(CommandNames.Change, {
+                    file: file1Consumer1.path,
+                    line: 2,
+                    offset: 1,
+                    endLine: 2,
+                    endOffset: 1,
+                    insertString: `export var T: number;`
+                });
+                session.executeCommand(changeModuleFile1ShapeRequest1);
+                session.executeCommand(changeFile1Consumer1ShapeRequest);
+                sendAffectedFileRequestAndCheckResult(session, moduleFile1FileListRequest, [{ projectFileName: configFile.path, files: [moduleFile1, file1Consumer1, file1Consumer1Consumer1] }]);
+            });
+
+            it("should work fine for files with circular references", () => {
+                const file1: FileOrFolder = {
+                    path: "/a/b/file1.ts",
+                    content: `
+                    /// <reference path="./file2.ts" />
+                    export var t1 = 10;`
+                };
+                const file2: FileOrFolder = {
+                    path: "/a/b/file2.ts",
+                    content: `
+                    /// <reference path="./file1.ts" />
+                    export var t2 = 10;`
+                };
+                const host = createServerHost([file1, file2, configFile]);
+                const typingsInstaller = createTestTypingsInstaller(host);
+                const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+                openFilesForSession([file1, file2], session);
+                const file1AffectedListRequest = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: file1.path });
+                sendAffectedFileRequestAndCheckResult(session, file1AffectedListRequest, [{ projectFileName: configFile.path, files: [file1, file2] }]);
+            });
+
+            it("should return results for all projects if not specifying projectFileName", () => {
+                const file1: FileOrFolder = { path: "/a/b/file1.ts", content: "export var t = 10;" };
+                const file2: FileOrFolder = { path: "/a/b/file2.ts", content: `import {t} from "./file1"; var t2 = 11;` };
+                const file3: FileOrFolder = { path: "/a/c/file2.ts", content: `import {t} from "../b/file1"; var t3 = 11;` };
+                const configFile1: FileOrFolder = { path: "/a/b/tsconfig.json", content: `{ "compileOnSave": true }` };
+                const configFile2: FileOrFolder = { path: "/a/c/tsconfig.json", content: `{ "compileOnSave": true }` };
+
+                const host = createServerHost([file1, file2, file3, configFile1, configFile2]);
+                const session = createSession(host);
+
+                openFilesForSession([file1, file2, file3], session);
+                const file1AffectedListRequest = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: file1.path });
+
+                sendAffectedFileRequestAndCheckResult(session, file1AffectedListRequest, [
+                    { projectFileName: configFile1.path, files: [file1, file2] },
+                    { projectFileName: configFile2.path, files: [file1, file3] }
+                ]);
+            });
+
+            it("should detect removed code file", () => {
+                const referenceFile1: FileOrFolder = {
+                    path: "/a/b/referenceFile1.ts",
+                    content: `
+                    /// <reference path="./moduleFile1.ts" />
+                    export var x = Foo();`
+                };
+                const host = createServerHost([moduleFile1, referenceFile1, configFile]);
+                const session = createSession(host);
+
+                openFilesForSession([referenceFile1], session);
+                host.reloadFS([referenceFile1, configFile]);
+                host.triggerFileWatcherCallback(moduleFile1.path, /*removed*/ true);
+
+                const request = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: referenceFile1.path });
+                sendAffectedFileRequestAndCheckResult(session, request, [
+                    { projectFileName: configFile.path, files: [referenceFile1] }
+                ]);
+                const requestForMissingFile = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: moduleFile1.path });
+                sendAffectedFileRequestAndCheckResult(session, requestForMissingFile, []);
+            });
+
+            it("should detect non-existing code file", () => {
+                const referenceFile1: FileOrFolder = {
+                    path: "/a/b/referenceFile1.ts",
+                    content: `
+                    /// <reference path="./moduleFile2.ts" />
+                    export var x = Foo();`
+                };
+                const host = createServerHost([referenceFile1, configFile]);
+                const session = createSession(host);
+
+                openFilesForSession([referenceFile1], session);
+                const request = makeSessionRequest<server.protocol.FileRequestArgs>(CommandNames.CompileOnSaveAffectedFileList, { file: referenceFile1.path });
+                sendAffectedFileRequestAndCheckResult(session, request, [
+                    { projectFileName: configFile.path, files: [referenceFile1] }
+                ]);
+            });
+        });
+    });
+
+    describe("EmitFile test", () => {
+        it("should emit specified file", () => {
+            const file1 = {
+                path: "/a/b/f1.ts",
+                content: `export function Foo() { return 10; }`
+            };
+            const file2 = {
+                path: "/a/b/f2.ts",
+                content: `import {Foo} from "./f1"; let y = Foo();`
+            };
+            const configFile = {
+                path: "/a/b/tsconfig.json",
+                content: `{}`
+            };
+            const host = createServerHost([file1, file2, configFile, libFile]);
+            const typingsInstaller = createTestTypingsInstaller(host);
+            const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
+
+            openFilesForSession([file1, file2], session);
+            const compileFileRequest = makeSessionRequest<server.protocol.CompileOnSaveEmitFileRequestArgs>(CommandNames.CompileOnSaveEmitFile, { file: file1.path, projectFileName: configFile.path });
+            session.executeCommand(compileFileRequest);
+
+            const expectedEmittedFileName = "/a/b/f1.js";
+            assert.isTrue(host.fileExists(expectedEmittedFileName));
+            assert.equal(host.readFile(expectedEmittedFileName), `"use strict";\r\nfunction Foo() { return 10; }\r\nexports.Foo = Foo;\r\n`);
+        });
+    });
+}

src/harness/unittests/configurationExtension.ts

@@ -0,0 +1,187 @@
+/// <reference path="..\harness.ts" />
+/// <reference path="..\virtualFileSystem.ts" />
+
+namespace ts {
+    const testContents = {
+        "/dev/tsconfig.json": `{
+  "extends": "./configs/base",
+  "files": [
+    "main.ts",
+    "supplemental.ts"
+  ]
+}`,
+        "/dev/tsconfig.nostrictnull.json": `{
+  "extends": "./tsconfig",
+  "compilerOptions": {
+    "strictNullChecks": false
+  }
+}`,
+        "/dev/configs/base.json": `{
+  "compilerOptions": {
+    "allowJs": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true
+  }
+}`,
+        "/dev/configs/tests.json": `{
+  "compilerOptions": {
+    "preserveConstEnums": true,
+    "removeComments": false,
+    "sourceMap": true
+  },
+  "exclude": [
+    "../tests/baselines",
+    "../tests/scenarios"
+  ],
+  "include": [
+    "../tests/**/*.ts"
+  ]
+}`,
+        "/dev/circular.json": `{
+    "extends": "./circular2",
+    "compilerOptions": {
+        "module": "amd"
+    }
+}`,
+        "/dev/circular2.json": `{
+    "extends": "./circular",
+    "compilerOptions": {
+        "module": "commonjs"
+    }
+}`,
+        "/dev/missing.json": `{
+    "extends": "./missing2",
+    "compilerOptions": {
+        "types": []
+    }
+}`,
+        "/dev/failure.json": `{
+    "extends": "./failure2.json",
+    "compilerOptions": {
+        "typeRoots": []
+    }
+}`,
+        "/dev/failure2.json": `{
+    "excludes": ["*.js"]
+}`,
+        "/dev/configs/first.json": `{
+    "extends": "./base",
+    "compilerOptions": {
+        "module": "commonjs"
+    },
+    "files": ["../main.ts"]
+}`,
+        "/dev/configs/second.json": `{
+    "extends": "./base",
+    "compilerOptions": {
+        "module": "amd"
+    },
+    "include": ["../supplemental.*"]
+}`,
+        "/dev/extends.json": `{ "extends": 42 }`,
+        "/dev/extends2.json": `{ "extends": "configs/base" }`,
+        "/dev/main.ts": "",
+        "/dev/supplemental.ts": "",
+        "/dev/tests/unit/spec.ts": "",
+        "/dev/tests/utils.ts": "",
+        "/dev/tests/scenarios/first.json": "",
+        "/dev/tests/baselines/first/output.ts": ""
+    };
+
+    const caseInsensitiveBasePath = "c:/dev/";
+    const caseInsensitiveHost = new Utils.MockParseConfigHost(caseInsensitiveBasePath, /*useCaseSensitiveFileNames*/ false, mapObject(testContents, (key, content) => [`c:${key}`, content]));
+
+    const caseSensitiveBasePath = "/dev/";
+    const caseSensitiveHost = new Utils.MockParseConfigHost(caseSensitiveBasePath, /*useCaseSensitiveFileNames*/ true, testContents);
+
+    function verifyDiagnostics(actual: Diagnostic[], expected: {code: number, category: DiagnosticCategory, messageText: string}[]) {
+        assert.isTrue(expected.length === actual.length, `Expected error: ${JSON.stringify(expected)}. Actual error: ${JSON.stringify(actual)}.`);
+        for (let i = 0; i < actual.length; i++) {
+            const actualError = actual[i];
+            const expectedError = expected[i];
+            assert.equal(actualError.code, expectedError.code, "Error code mismatch");
+            assert.equal(actualError.category, expectedError.category, "Category mismatch");
+            assert.equal(flattenDiagnosticMessageText(actualError.messageText, "\n"), expectedError.messageText);
+        }
+    }
+
+    describe("Configuration Extension", () => {
+        forEach<[string, string, Utils.MockParseConfigHost], void>([
+            ["under a case insensitive host", caseInsensitiveBasePath, caseInsensitiveHost],
+            ["under a case sensitive host", caseSensitiveBasePath, caseSensitiveHost]
+        ], ([testName, basePath, host]) => {
+            function testSuccess(name: string, entry: string, expected: CompilerOptions, expectedFiles: string[]) {
+                it(name, () => {
+                    const {config, error} = ts.readConfigFile(entry, name => host.readFile(name));
+                    assert(config && !error, flattenDiagnosticMessageText(error && error.messageText, "\n"));
+                    const parsed = ts.parseJsonConfigFileContent(config, host, basePath, {}, entry);
+                    assert(!parsed.errors.length, flattenDiagnosticMessageText(parsed.errors[0] && parsed.errors[0].messageText, "\n"));
+                    expected.configFilePath = entry;
+                    assert.deepEqual(parsed.options, expected);
+                    assert.deepEqual(parsed.fileNames, expectedFiles);
+                });
+            }
+
+            function testFailure(name: string, entry: string, expectedDiagnostics: {code: number, category: DiagnosticCategory, messageText: string}[]) {
+                it(name, () => {
+                    const {config, error} = ts.readConfigFile(entry, name => host.readFile(name));
+                    assert(config && !error, flattenDiagnosticMessageText(error && error.messageText, "\n"));
+                    const parsed = ts.parseJsonConfigFileContent(config, host, basePath, {}, entry);
+                    verifyDiagnostics(parsed.errors, expectedDiagnostics);
+                });
+            }
+
+            describe(testName, () => {
+                testSuccess("can resolve an extension with a base extension", "tsconfig.json", {
+                    allowJs: true,
+                    noImplicitAny: true,
+                    strictNullChecks: true,
+                }, [
+                    combinePaths(basePath, "main.ts"),
+                    combinePaths(basePath, "supplemental.ts"),
+                ]);
+
+                testSuccess("can resolve an extension with a base extension that overrides options", "tsconfig.nostrictnull.json", {
+                    allowJs: true,
+                    noImplicitAny: true,
+                    strictNullChecks: false,
+                }, [
+                    combinePaths(basePath, "main.ts"),
+                    combinePaths(basePath, "supplemental.ts"),
+                ]);
+
+                testFailure("can report errors on circular imports", "circular.json", [
+                    {
+                        code: 18000,
+                        category: DiagnosticCategory.Error,
+                        messageText: `Circularity detected while resolving configuration: ${[combinePaths(basePath, "circular.json"), combinePaths(basePath, "circular2.json"), combinePaths(basePath, "circular.json")].join(" -> ")}`
+                    }
+                ]);
+
+                testFailure("can report missing configurations", "missing.json", [{
+                    code: 6096,
+                    category: DiagnosticCategory.Message,
+                    messageText: `File './missing2' does not exist.`
+                }]);
+
+                testFailure("can report errors in extended configs", "failure.json", [{
+                    code: 6114,
+                    category: DiagnosticCategory.Error,
+                    messageText: `Unknown option 'excludes'. Did you mean 'exclude'?`
+                }]);
+
+                testFailure("can error when 'extends' is not a string", "extends.json", [{
+                    code: 5024,
+                    category: DiagnosticCategory.Error,
+                    messageText: `Compiler option 'extends' requires a value of type string.`
+                }]);
+
+                testFailure("can error when 'extends' is neither relative nor rooted.", "extends2.json", [{
+                    code: 18001,
+                    category: DiagnosticCategory.Error,
+                    messageText: `The path in an 'extends' options must be relative or rooted.`
+                }]);
+            });
+        });
+    });
+}

src/harness/unittests/convertCompilerOptionsFromJson.ts

@@ -176,7 +176,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--target' option must be:  'es3', 'es5', 'es6', 'es2015'",
+                        messageText: "Argument for '--target' option must be:  'es3', 'es5', 'es6', 'es2015', 'es2016', 'es2017'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -233,7 +233,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -264,7 +264,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -295,7 +295,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -326,7 +326,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
+                        messageText: "Argument for '--lib' option must be:  'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'dom', 'dom.iterable', 'webworker', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory'",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -403,6 +403,9 @@ namespace ts {
                 {
                     compilerOptions: <CompilerOptions>{
                         allowJs: true,
+                        maxNodeModuleJsDepth: 2,
+                        allowSyntheticDefaultImports: true,
+                        skipLibCheck: true,
                         module: ModuleKind.CommonJS,
                         target: ScriptTarget.ES5,
                         noImplicitAny: false,
@@ -429,6 +432,9 @@ namespace ts {
                 {
                     compilerOptions: <CompilerOptions>{
                         allowJs: false,
+                        maxNodeModuleJsDepth: 2,
+                        allowSyntheticDefaultImports: true,
+                        skipLibCheck: true,
                         module: ModuleKind.CommonJS,
                         target: ScriptTarget.ES5,
                         noImplicitAny: false,
@@ -450,7 +456,10 @@ namespace ts {
                 {
                     compilerOptions:
                     {
-                        allowJs: true
+                        allowJs: true,
+                        maxNodeModuleJsDepth: 2,
+                        allowSyntheticDefaultImports: true,
+                        skipLibCheck: true
                     },
                     errors: [{
                         file: undefined,
@@ -469,7 +478,10 @@ namespace ts {
                 {
                     compilerOptions:
                     {
-                        allowJs: true
+                        allowJs: true,
+                        maxNodeModuleJsDepth: 2,
+                        allowSyntheticDefaultImports: true,
+                        skipLibCheck: true
                     },
                     errors: <Diagnostic[]>[]
                 }

src/harness/unittests/moduleResolution.ts

@@ -1017,7 +1017,7 @@ import b = require("./moduleB");
             const files = [f1, f2, f3, f4];
 
             const names = map(files, f => f.name);
-            const sourceFiles = arrayToMap(map(files, f => createSourceFile(f.name, f.content, ScriptTarget.ES6)), f => f.fileName);
+            const sourceFiles = arrayToMap(map(files, f => createSourceFile(f.name, f.content, ScriptTarget.ES2015)), f => f.fileName);
             const compilerHost: CompilerHost = {
                 fileExists : fileName => fileName in sourceFiles,
                 getSourceFile: fileName => sourceFiles[fileName],

src/harness/unittests/projectErrors.ts

@@ -0,0 +1,186 @@
+/// <reference path="../harness.ts" />
+/// <reference path="./tsserverProjectSystem.ts" />
+/// <reference path="../../server/typingsInstaller/typingsInstaller.ts" />
+
+namespace ts.projectSystem {
+    describe("Project errors", () => {
+        function checkProjectErrors(projectFiles: server.ProjectFilesWithTSDiagnostics, expectedErrors: string[]) {
+            assert.isTrue(projectFiles !== undefined, "missing project files");
+            const errors = projectFiles.projectErrors;
+            assert.equal(errors ? errors.length : 0, expectedErrors.length, `expected ${expectedErrors.length} error in the list`);
+            if (expectedErrors.length) {
+                for (let i = 0; i < errors.length; i++) {
+                    const actualMessage = flattenDiagnosticMessageText(errors[i].messageText, "\n");
+                    const expectedMessage = expectedErrors[i];
+                    assert.isTrue(actualMessage.indexOf(expectedMessage) === 0, `error message does not match, expected ${actualMessage} to start with ${expectedMessage}`);
+                }
+            }
+        }
+
+        it("external project - diagnostics for missing files", () => {
+            const file1 = {
+                path: "/a/b/app.ts",
+                content: ""
+            };
+            const file2 = {
+                path: "/a/b/lib.ts",
+                content: ""
+            };
+            // only file1 exists - expect error
+            const host = createServerHost([file1]);
+            const projectService = createProjectService(host);
+            const projectFileName = "/a/b/test.csproj";
+
+            {
+                projectService.openExternalProject({
+                    projectFileName,
+                    options: {},
+                    rootFiles: toExternalFiles([file1.path, file2.path])
+                });
+
+                projectService.checkNumberOfProjects({ externalProjects: 1 });
+                const knownProjects = projectService.synchronizeProjectList([]);
+                checkProjectErrors(knownProjects[0], ["File '/a/b/lib.ts' not found."]);
+            }
+            // only file2 exists - expect error
+            host.reloadFS([file2]);
+            {
+                projectService.openExternalProject({
+                    projectFileName,
+                    options: {},
+                    rootFiles: toExternalFiles([file1.path, file2.path])
+                });
+                projectService.checkNumberOfProjects({ externalProjects: 1 });
+                const knownProjects = projectService.synchronizeProjectList([]);
+                checkProjectErrors(knownProjects[0], ["File '/a/b/app.ts' not found."]);
+            }
+
+            // both files exist - expect no errors
+            host.reloadFS([file1, file2]);
+            {
+                projectService.openExternalProject({
+                    projectFileName,
+                    options: {},
+                    rootFiles: toExternalFiles([file1.path, file2.path])
+                });
+
+                projectService.checkNumberOfProjects({ externalProjects: 1 });
+                const knownProjects = projectService.synchronizeProjectList([]);
+                checkProjectErrors(knownProjects[0], []);
+            }
+        });
+
+        it("configured projects - diagnostics for missing files", () => {
+            const file1 = {
+                path: "/a/b/app.ts",
+                content: ""
+            };
+            const file2 = {
+                path: "/a/b/lib.ts",
+                content: ""
+            };
+            const config = {
+                path: "/a/b/tsconfig.json",
+                content: JSON.stringify({ files: [file1, file2].map(f => getBaseFileName(f.path)) })
+            };
+            const host = createServerHost([file1, config]);
+            const projectService = createProjectService(host);
+
+            projectService.openClientFile(file1.path);
+            projectService.checkNumberOfProjects({ configuredProjects: 1 });
+            checkProjectErrors(projectService.synchronizeProjectList([])[0], ["File '/a/b/lib.ts' not found."]);
+
+            host.reloadFS([file1, file2, config]);
+
+            projectService.openClientFile(file1.path);
+            projectService.checkNumberOfProjects({ configuredProjects: 1 });
+            checkProjectErrors(projectService.synchronizeProjectList([])[0], []);
+        });
+
+        it("configured projects - diagnostics for corrupted config 1", () => {
+            const file1 = {
+                path: "/a/b/app.ts",
+                content: ""
+            };
+            const file2 = {
+                path: "/a/b/lib.ts",
+                content: ""
+            };
+            const correctConfig = {
+                path: "/a/b/tsconfig.json",
+                content: JSON.stringify({ files: [file1, file2].map(f => getBaseFileName(f.path)) })
+            };
+            const corruptedConfig = {
+                path: correctConfig.path,
+                content: correctConfig.content.substr(1)
+            };
+            const host = createServerHost([file1, file2, corruptedConfig]);
+            const projectService = createProjectService(host);
+
+            projectService.openClientFile(file1.path);
+            {
+                projectService.checkNumberOfProjects({ configuredProjects: 1 });
+                const configuredProject = forEach(projectService.synchronizeProjectList([]), f => f.info.projectName === corruptedConfig.path && f);
+                assert.isTrue(configuredProject !== undefined, "should find configured project");
+                checkProjectErrors(configuredProject,  [
+                    "')' expected.",
+                    "Declaration or statement expected.",
+                    "Declaration or statement expected.",
+                    "Failed to parse file '/a/b/tsconfig.json'"
+                ]);
+            }
+            // fix config and trigger watcher
+            host.reloadFS([file1, file2, correctConfig]);
+            host.triggerFileWatcherCallback(correctConfig.path, /*false*/);
+            {
+                projectService.checkNumberOfProjects({ configuredProjects: 1 });
+                const configuredProject = forEach(projectService.synchronizeProjectList([]), f => f.info.projectName === corruptedConfig.path && f);
+                assert.isTrue(configuredProject !== undefined, "should find configured project");
+                checkProjectErrors(configuredProject, []);
+            }
+        });
+
+        it("configured projects - diagnostics for corrupted config 2", () => {
+            const file1 = {
+                path: "/a/b/app.ts",
+                content: ""
+            };
+            const file2 = {
+                path: "/a/b/lib.ts",
+                content: ""
+            };
+            const correctConfig = {
+                path: "/a/b/tsconfig.json",
+                content: JSON.stringify({ files: [file1, file2].map(f => getBaseFileName(f.path)) })
+            };
+            const corruptedConfig = {
+                path: correctConfig.path,
+                content: correctConfig.content.substr(1)
+            };
+            const host = createServerHost([file1, file2, correctConfig]);
+            const projectService = createProjectService(host);
+
+            projectService.openClientFile(file1.path);
+            {
+                projectService.checkNumberOfProjects({ configuredProjects: 1 });
+                const configuredProject = forEach(projectService.synchronizeProjectList([]), f => f.info.projectName === corruptedConfig.path && f);
+                assert.isTrue(configuredProject !== undefined, "should find configured project");
+                checkProjectErrors(configuredProject, []);
+            }
+            // break config and trigger watcher
+            host.reloadFS([file1, file2, corruptedConfig]);
+            host.triggerFileWatcherCallback(corruptedConfig.path, /*false*/);
+            {
+                projectService.checkNumberOfProjects({ configuredProjects: 1 });
+                const configuredProject = forEach(projectService.synchronizeProjectList([]), f => f.info.projectName === corruptedConfig.path && f);
+                assert.isTrue(configuredProject !== undefined, "should find configured project");
+                checkProjectErrors(configuredProject, [
+                    "')' expected.",
+                    "Declaration or statement expected.",
+                    "Declaration or statement expected.",
+                    "Failed to parse file '/a/b/tsconfig.json'"
+                ]);
+            }
+        });
+    });
+}

src/harness/unittests/services/formatting/testCode/testCode/formatting/classes.ts

@@ -1,79 +0,0 @@
-         class                    a                  {    
-                                                        constructor       (       n   :                 number    )             ;
-                                                        constructor       (       s   :                 string    )             ;
-                                                        constructor       (       ns   :                 any    )                            {    
-
-                                                        }
-
-                                                            public                 pgF       (           )                            {                  }   ;
-
-                                                            public                 pv   ;
-                                                            public                 get              d       (           )                            {    
-                                                                                                                return              30   ;
-                                                        }
-                                                            public                 set              d       (           )                            {    
-                                                        }
-
-                                                            public                 static                    get              p2       (           )                            {    
-                                                                                                                return                  {                  x   :                 30   ,                  y   :                 40              }   ;
-                                                        }
-
-                                                                         private                static                    d2       (           )                            {    
-                                                        }
-                                                                         private                static                    get              p3       (           )                            {    
-                                                                                                                return              "string"   ;
-                                                        }
-                                                                         private                pv3   ;
-
-                                                                         private                foo       (       n   :                 number    )             :                 string   ;
-                                                                         private                foo       (       s   :                 string    )             :                 string   ;
-                                                                         private                foo       (       ns   :                 any    )                            {    
-                                                                                                                return              ns.toString       (           )             ;
-                                                        }
-}
-
-         class                    b              extends              a                  {    
-}
-
-         class   m1b      { 
-
-}
-
-                                                interface   m1ib                               { 
-                                                        
-  }
-         class                    c              extends              m1b                  {    
-}
-
-         class                    ib2              implements              m1ib                  {    
-}
-
-    declare                            class                    aAmbient                  {    
-                                                        constructor                     (       n   :                 number    )             ;
-                                                        constructor                     (       s   :                 string    )             ;
-                                                            public                 pgF       (           )             :                 void   ;
-                                                            public                 pv   ;
-                                                            public                 d                 :                 number   ;
-                                                        static                    p2                 :                     {                  x   :                 number   ;              y   :                 number   ;              }   ;
-                                                        static                    d2       (           )             ;
-                                                        static                    p3   ;
-                                                                         private                pv3   ;
-                                                                         private                foo       (       s    )             ;
-}
-
-         class                    d                  {    
-                                                                         private                foo       (       n   :                 number    )             :                 string   ;
-                                                                         private                foo       (       ns   :                 any    )                            {    
-                                                                                                                return              ns.toString       (           )             ;
-                                                        }
-                                                                         private                foo       (       s   :                 string    )             :                 string   ;
-}
-
-         class                    e                  {    
-                                                                         private                foo       (       ns   :                 any    )                            {    
-                                                                                                                return              ns.toString       (           )             ;
-                                                        }
-                                                                         private                foo       (       s   :                 string    )             :                 string   ;
-                                                                         private                foo       (       n   :                 number    )             :                 string   ;
-}
-

src/harness/unittests/services/formatting/testCode/testCode/formatting/classesBaseline.ts

@@ -1,79 +0,0 @@
-class a {
-    constructor(n: number);
-    constructor(s: string);
-    constructor(ns: any) {
-
-    }
-
-    public pgF() { };
-
-    public pv;
-    public get d() {
-        return 30;
-    }
-    public set d() {
-    }
-
-    public static get p2() {
-        return { x: 30, y: 40 };
-    }
-
-    private static d2() {
-    }
-    private static get p3() {
-        return "string";
-    }
-    private pv3;
-
-    private foo(n: number): string;
-    private foo(s: string): string;
-    private foo(ns: any) {
-        return ns.toString();
-    }
-}
-
-class b extends a {
-}
-
-class m1b {
-
-}
-
-interface m1ib {
-
-}
-class c extends m1b {
-}
-
-class ib2 implements m1ib {
-}
-
-declare class aAmbient {
-    constructor(n: number);
-    constructor(s: string);
-    public pgF(): void;
-    public pv;
-    public d: number;
-    static p2: { x: number; y: number; };
-    static d2();
-    static p3;
-    private pv3;
-    private foo(s);
-}
-
-class d {
-    private foo(n: number): string;
-    private foo(ns: any) {
-        return ns.toString();
-    }
-    private foo(s: string): string;
-}
-
-class e {
-    private foo(ns: any) {
-        return ns.toString();
-    }
-    private foo(s: string): string;
-    private foo(n: number): string;
-}
-

src/harness/unittests/services/formatting/testCode/testCode/formatting/colonAndQMark.ts

@@ -1,4 +0,0 @@
-class foo {
-    constructor (n?: number, m? = 5, o?: string = "") { }
-    x:number = 1?2:3;
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/colonAndQMarkBaseline.ts

@@ -1,4 +0,0 @@
-class foo {
-    constructor(n?: number, m? = 5, o?: string = "") { }
-    x: number = 1 ? 2 : 3;
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/documentReadyFunction.ts

@@ -1,3 +0,0 @@
-$    (   document   )   .  ready  (   function   (   )   {   
-    alert    (           'i am ready'  )   ;
-           }                 );

src/harness/unittests/services/formatting/testCode/testCode/formatting/documentReadyFunctionBaseLine.ts

@@ -1,3 +0,0 @@
-$(document).ready(function() {
-    alert('i am ready');
-});

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyBlock.ts

@@ -1 +0,0 @@
-{}

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyBlockBaseline.ts

@@ -1 +0,0 @@
-{ }

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyInterfaceLiteral.ts

@@ -1,10 +0,0 @@
-    function    foo  (  x  :    {    }    )    {    }
-
-foo    (  {     }   )    ;
-
-
-    
-            interface    bar    {
-                x   :    {     }   ;
-       y  :       (         )    =>    {     }   ;   
-                                                    }

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyInterfaceLiteralBaseLine.ts

@@ -1,10 +0,0 @@
-function foo(x: {}) { }
-
-foo({});
-
-
-
-interface bar {
-    x: {};
-    y: () => {};
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/fatArrowFunctions.ts

@@ -1,112 +0,0 @@
-// valid    
-    (         )           =>    1  ;   
-    (        arg )           =>    2  ;   
-        arg       =>    2  ;   
-      (        arg     = 1 )           =>    3  ;   
-    (        arg    ?        )           =>    4  ;   
-    (        arg    :    number )           =>    5  ;   
-      (        arg    :    number     = 0 )           =>    6  ;   
-    (        arg        ?                  :    number )           =>    7  ;   
-    (                 ...     arg    :    number   [      ]    )           =>    8  ;   
-      (        arg1   ,    arg2 )           =>    12  ;   
-    (        arg1     = 1   ,    arg2     =3 )           =>    13  ;   
-      (        arg1    ?          ,    arg2    ?        )           =>    14  ;   
-    (        arg1    :    number   ,    arg2    :    number )           =>    15  ;   
-    (        arg1    :    number     = 0   ,    arg2    :    number     = 1 )           =>    16  ;   
-      (        arg1    ?           :    number   ,    arg2    ?           :    number )           =>    17  ;   
-    (        arg1   ,             ...     arg2    :    number   [      ]    )           =>    18  ;   
-      (        arg1   ,    arg2    ?           :    number )           =>    19  ;   
-
-// in paren
-    (            (         )           =>    21 )      ;   
-    (            (        arg )           =>    22 )      ;   
-    (            (        arg     = 1 )           =>    23 )      ;   
-    (            (        arg    ?        )           =>    24 )      ;   
-    (            (        arg    :    number )           =>    25 )      ;   
-    (            (        arg    :    number     = 0 )           =>    26 )      ;   
-    (            (        arg    ?           :    number )           =>    27 )      ;   
-    (            (                 ...     arg    :    number   [      ]    )           =>    28 )      ;   
-
-// in multiple paren
-    (            (            (            (            (        arg )           =>    { return 32  ;    } )     )     )     )      ;   
-
-// in ternary exression
-      false        ?            (         )           =>    41     :    null  ;   
-   false        ?            (        arg )           =>    42     :    null  ;   
-    false        ?            (        arg     = 1 )           =>    43     :    null  ;   
-      false        ?            (        arg    ?        )           =>    44     :    null  ;   
-    false        ?            (        arg    :    number )           =>    45     :    null  ;   
-   false        ?            (        arg    ?           :    number )           =>    46     :    null  ;   
-      false        ?            (        arg    ?           :    number     = 0 )           =>    47     :    null  ;   
-   false        ?            (                 ...     arg    :    number   [      ]    )           =>    48     :    null  ;   
-
-// in ternary exression within paren
-   false        ?            (            (         )           =>    51 )         :    null  ;   
-    false        ?            (            (        arg )           =>    52 )         :    null  ;   
-    false        ?            (            (        arg     = 1 )           =>    53 )         :    null  ;   
-      false        ?            (            (        arg    ?        )           =>    54 )         :    null  ;   
-    false        ?            (            (        arg    :    number )           =>    55 )         :    null  ;   
-      false        ?            (            (        arg    ?           :    number )           =>    56 )         :    null  ;   
-    false        ?            (            (        arg    ?           :    number     = 0 )           =>    57 )         :    null  ;   
-   false        ?            (            (                 ...     arg    :    number   [      ]    )           =>    58 )         :    null  ;   
-
-// ternary exression's else clause
-   false        ?        null     :        (         )           =>    61  ;   
-        false        ?        null     :        (        arg )           =>    62  ;   
-   false        ?        null     :        (        arg     = 1 )           =>    63  ;   
-      false        ?        null     :        (        arg    ?        )           =>    64  ;   
-   false        ?        null     :        (        arg    :    number )           =>    65  ;   
-    false        ?        null     :        (        arg    ?           :    number )           =>    66  ;   
-        false        ?        null     :        (        arg    ?           :    number     = 0 )           =>    67  ;   
-    false        ?        null     :        (                 ...     arg    :    number   [      ]    )           =>    68  ;   
-
-
-// nested ternary expressions
-    (        a    ?        )           =>    { return a  ;    }     ?            (        b    ?         )           =>    { return b  ;    }     :        (        c    ?         )           =>    { return c  ;    }  ;   
-
-//multiple levels
-    (        a    ?        )           =>    { return a  ;    }     ?            (        b )          =>       (        c )          =>   81     :        (        c )          =>       (        d )          =>   82  ;   
-
-
-// In Expressions
-    (            (        arg )           =>    90 )     instanceof Function  ;   
-      (            (        arg     = 1 )           =>    91 )     instanceof Function  ;   
-        (            (        arg    ?         )           =>    92 )     instanceof Function  ;   
-      (            (        arg    :    number )           =>    93 )     instanceof Function  ;   
-    (            (        arg    :    number     = 1 )           =>    94 )     instanceof Function  ;   
-        (            (        arg    ?           :    number )           =>    95 )     instanceof Function  ;   
-      (            (                 ...     arg    :    number   [      ]    )           =>    96 )     instanceof Function  ;   
-
-''    +        (        arg )           =>    100  ;   
-        (            (        arg )           =>    0 )        +    ''    +        (        arg )           =>    101  ;   
-          (            (        arg     = 1 )           =>    0 )        +    ''    +        (        arg     = 2 )           =>    102  ;   
-    (            (        arg    ?        )           =>    0 )        +    ''    +        (        arg    ?        )           =>    103  ;   
-      (            (        arg    :   number )           =>    0 )        +    ''    +        (        arg    :   number )           =>    104  ;   
-        (            (        arg    :   number     = 1 )           =>    0 )        +    ''    +        (        arg    :   number     = 2 )           =>    105  ;   
-    (            (        arg    ?           :   number     = 1 )           =>    0 )        +    ''    +        (        arg    ?           :   number     = 2 )           =>    106  ;   
-      (            (                 ...     arg    :   number   [      ]    )           =>    0 )        +    ''    +        (                 ...     arg    :   number   [      ]    )           =>    107  ;   
-    (            (        arg1   ,    arg2    ?        )           =>    0 )        +    ''    +        (        arg1   ,   arg2    ?        )           =>    108  ;   
-      (            (        arg1   ,             ...     arg2    :   number   [      ]    )           =>    0 )        +    ''    +        (        arg1   ,             ...     arg2    :   number   [      ]    )           =>    108  ;   
-
-
-// Function Parameters
-function foo    (                 ...     arg    :    any   [      ]    )     { }
-
-foo    (        
-        (        a )           =>    110   ,    
-        (            (        a )           =>    111 )       ,    
-        (        a )           =>    {
-        return 112  ;   
-    }   ,   
-        (        a    ?         )           =>    113   ,    
-        (        a   ,    b    ?         )           =>    114   ,    
-        (        a    :    number )           =>    115   ,    
-        (        a    :    number     = 0 )           =>    116   ,    
-        (        a     = 0 )           =>    117   ,    
-        (        a    ?           :    number     = 0 )           =>    118   ,    
-        (        a    ?    ,   b   ?          :    number     = 0 )           =>    118   ,    
-        (                 ...     a    :    number   [      ]    )           =>    119   ,    
-        (        a   ,    b    ?            = 0   ,             ...     c    :    number   [      ]    )           =>    120   ,   
-        (        a )           =>        (        b )           =>        (        c )           =>    121   ,   
-        false       ?            (        a )           =>    0     :        (        b )           =>    122
- )      ;   

src/harness/unittests/services/formatting/testCode/testCode/formatting/fatArrowFunctionsBaseline.ts

@@ -1,112 +0,0 @@
-// valid    
-() => 1;
-(arg) => 2;
-arg => 2;
-(arg = 1) => 3;
-(arg?) => 4;
-(arg: number) => 5;
-(arg: number = 0) => 6;
-(arg?: number) => 7;
-(...arg: number[]) => 8;
-(arg1, arg2) => 12;
-(arg1 = 1, arg2 = 3) => 13;
-(arg1?, arg2?) => 14;
-(arg1: number, arg2: number) => 15;
-(arg1: number = 0, arg2: number = 1) => 16;
-(arg1?: number, arg2?: number) => 17;
-(arg1, ...arg2: number[]) => 18;
-(arg1, arg2?: number) => 19;
-
-// in paren
-(() => 21);
-((arg) => 22);
-((arg = 1) => 23);
-((arg?) => 24);
-((arg: number) => 25);
-((arg: number = 0) => 26);
-((arg?: number) => 27);
-((...arg: number[]) => 28);
-
-// in multiple paren
-(((((arg) => { return 32; }))));
-
-// in ternary exression
-false ? () => 41 : null;
-false ? (arg) => 42 : null;
-false ? (arg = 1) => 43 : null;
-false ? (arg?) => 44 : null;
-false ? (arg: number) => 45 : null;
-false ? (arg?: number) => 46 : null;
-false ? (arg?: number = 0) => 47 : null;
-false ? (...arg: number[]) => 48 : null;
-
-// in ternary exression within paren
-false ? (() => 51) : null;
-false ? ((arg) => 52) : null;
-false ? ((arg = 1) => 53) : null;
-false ? ((arg?) => 54) : null;
-false ? ((arg: number) => 55) : null;
-false ? ((arg?: number) => 56) : null;
-false ? ((arg?: number = 0) => 57) : null;
-false ? ((...arg: number[]) => 58) : null;
-
-// ternary exression's else clause
-false ? null : () => 61;
-false ? null : (arg) => 62;
-false ? null : (arg = 1) => 63;
-false ? null : (arg?) => 64;
-false ? null : (arg: number) => 65;
-false ? null : (arg?: number) => 66;
-false ? null : (arg?: number = 0) => 67;
-false ? null : (...arg: number[]) => 68;
-
-
-// nested ternary expressions
-(a?) => { return a; } ? (b?) => { return b; } : (c?) => { return c; };
-
-//multiple levels
-(a?) => { return a; } ? (b) => (c) => 81 : (c) => (d) => 82;
-
-
-// In Expressions
-((arg) => 90) instanceof Function;
-((arg = 1) => 91) instanceof Function;
-((arg?) => 92) instanceof Function;
-((arg: number) => 93) instanceof Function;
-((arg: number = 1) => 94) instanceof Function;
-((arg?: number) => 95) instanceof Function;
-((...arg: number[]) => 96) instanceof Function;
-
-'' + (arg) => 100;
-((arg) => 0) + '' + (arg) => 101;
-((arg = 1) => 0) + '' + (arg = 2) => 102;
-((arg?) => 0) + '' + (arg?) => 103;
-((arg: number) => 0) + '' + (arg: number) => 104;
-((arg: number = 1) => 0) + '' + (arg: number = 2) => 105;
-((arg?: number = 1) => 0) + '' + (arg?: number = 2) => 106;
-((...arg: number[]) => 0) + '' + (...arg: number[]) => 107;
-((arg1, arg2?) => 0) + '' + (arg1, arg2?) => 108;
-((arg1, ...arg2: number[]) => 0) + '' + (arg1, ...arg2: number[]) => 108;
-
-
-// Function Parameters
-function foo(...arg: any[]) { }
-
-foo(
-        (a) => 110,
-        ((a) => 111),
-        (a) => {
-            return 112;
-        },
-        (a?) => 113,
-        (a, b?) => 114,
-        (a: number) => 115,
-        (a: number = 0) => 116,
-        (a = 0) => 117,
-        (a?: number = 0) => 118,
-        (a?, b?: number = 0) => 118,
-        (...a: number[]) => 119,
-        (a, b? = 0, ...c: number[]) => 120,
-        (a) => (b) => (c) => 121,
-        false ? (a) => 0 : (b) => 122
- );

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatDebuggerStatement.ts

@@ -1,2 +0,0 @@
-if(false){debugger;}
-  if    (   false   )   {    debugger  ;   }

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatDebuggerStatementBaseline.ts

@@ -1,2 +0,0 @@
-if (false) { debugger; }
-if (false) { debugger; }

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatvariableDeclarationList.ts

@@ -1,13 +0,0 @@
-var   fun1   =   function   (     )     {   
-            var               x   =   'foo'             ,
-                z   =   'bar'           ;
-                return  x            ;
-},
-
-fun2   =   (                function        (   f               )   {
-            var   fun   =   function   (        )       {
-                        console         .  log             (           f     (  )  )       ;
-            },
-            x   =   'Foo'           ;
-                return   fun            ;
-}   (           fun1            )   )       ;

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatvariableDeclarationListBaseline.ts

@@ -1,13 +0,0 @@
-var fun1 = function() {
-    var x = 'foo',
-        z = 'bar';
-    return x;
-},
-
-fun2 = (function(f) {
-    var fun = function() {
-        console.log(f());
-    },
-    x = 'Foo';
-    return fun;
-} (fun1));