merge with origin/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
@@ -52,3 +54,4 @@ internal/
 !tests/cases/projects/projectOption/**/node_modules
 !tests/cases/projects/NodeModulesSearch/**/*
 !tests/baselines/reference/project/nodeModules*/**/*
+.idea

.travis.yml

@@ -23,7 +23,7 @@ matrix:
 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

@@ -39,9 +39,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",
@@ -584,6 +586,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);
@@ -603,7 +606,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") {
@@ -752,6 +755,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();
@@ -781,8 +785,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);
 }
@@ -912,7 +916,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);
@@ -933,8 +937,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

@@ -66,7 +66,20 @@ var compilerSources = [
     "utilities.ts",
     "binder.ts",
     "checker.ts",
+    "factory.ts",
+    "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es6.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es7.ts",
+    "transformers/generators.ts",
+    "transformers/es6.ts",
+    "transformer.ts",
     "sourcemap.ts",
+    "comments.ts",
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
@@ -87,7 +100,20 @@ var servicesSources = [
     "utilities.ts",
     "binder.ts",
     "checker.ts",
+    "factory.ts",
+    "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es6.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es7.ts",
+    "transformers/generators.ts",
+    "transformers/es6.ts",
+    "transformer.ts",
     "sourcemap.ts",
+    "comments.ts",
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
@@ -96,15 +122,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",
@@ -207,6 +247,7 @@ var harnessSources = harnessCoreSources.concat([
     "moduleResolution.ts",
     "tsconfigParsing.ts",
     "commandLineParsing.ts",
+    "configurationExtension.ts",
     "convertCompilerOptionsFromJson.ts",
     "convertTypingOptionsFromJson.ts",
     "tsserverProjectSystem.ts",
@@ -346,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;
@@ -790,8 +834,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);
 }
 
@@ -802,10 +852,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);
@@ -825,7 +880,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") {
@@ -894,7 +949,7 @@ function runConsoleTests(defaultReporter, runInParallel) {
         }
     }
     function runLinter() {
-        if (!lintFlag) {
+        if (!lintFlag || dirty) {
             return;
         }
         var lint = jake.Task['lint'];
@@ -911,8 +966,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 });
 
@@ -929,8 +984,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 });
 
@@ -996,15 +1051,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);
         }
     }
 }
@@ -1043,7 +1101,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]);

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).

lib/lib.es2015.collection.d.ts

@@ -20,7 +20,7 @@ interface Map<K, V> {
     forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
-    set(key: K, value?: V): this;
+    set(key: K, value: V): this;
     readonly size: number;
 }
 
@@ -35,7 +35,7 @@ interface WeakMap<K, V> {
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;
-    set(key: K, value?: V): this;
+    set(key: K, value: V): this;
 }
 
 interface WeakMapConstructor {

lib/lib.es2015.proxy.d.ts

@@ -19,7 +19,7 @@ interface ProxyHandler<T> {
     setPrototypeOf? (target: T, v: any): boolean;
     isExtensible? (target: T): boolean;
     preventExtensions? (target: T): boolean;
-    getOwnPropertyDescriptor? (target: T, p: PropertyKey): PropertyDescriptor;
+    getOwnPropertyDescriptor? (target: T, p: PropertyKey): PropertyDescriptor | undefined;
     has? (target: T, p: PropertyKey): boolean;
     get? (target: T, p: PropertyKey, receiver: any): any;
     set? (target: T, p: PropertyKey, value: any, receiver: any): boolean;
@@ -35,4 +35,4 @@ interface ProxyConstructor {
     revocable<T>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
     new <T>(target: T, handler: ProxyHandler<T>): T
 }
-declare var Proxy: ProxyConstructor;
+declare var Proxy: ProxyConstructor;

lib/typescript.d.ts

@@ -417,10 +417,7 @@ declare namespace ts {
     interface ModifiersArray extends NodeArray<Modifier> {
         flags: NodeFlags;
     }
-    interface Token extends Node {
-        __tokenTag: any;
-    }
-    interface Modifier extends Token {
+    interface Modifier extends Node {
     }
     interface Identifier extends PrimaryExpression {
         text: string;
@@ -1738,6 +1735,7 @@ declare namespace ts {
         getCancellationToken?(): CancellationToken;
         getDefaultLibFileName(options: CompilerOptions): string;
         getDefaultLibLocation?(): string;
+        getDefaultTypeDirectiveNames?(rootPath: string): string[];
         writeFile: WriteFileCallback;
         getCurrentDirectory(): string;
         getDirectories(path: string): string[];
@@ -1883,6 +1881,8 @@ declare namespace ts {
     function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
     function getTypeParameterOwner(d: Declaration): Declaration;
     function isParameterPropertyDeclaration(node: ParameterDeclaration): boolean;
+    function startsWith(str: string, prefix: string): boolean;
+    function endsWith(str: string, suffix: string): boolean;
 }
 declare namespace ts {
     function createNode(kind: SyntaxKind, pos?: number, end?: number): Node;
@@ -1909,12 +1909,6 @@ declare namespace ts {
     function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
     function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
     function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
-    interface FormatDiagnosticsHost {
-        getCurrentDirectory(): string;
-        getCanonicalFileName(fileName: string): string;
-        getNewLine(): string;
-    }
-    function formatDiagnostics(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): string;
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     /**
       * Given a set of options, returns the set of type directive names

lib/typescriptServices.d.ts

@@ -417,10 +417,7 @@ declare namespace ts {
     interface ModifiersArray extends NodeArray<Modifier> {
         flags: NodeFlags;
     }
-    interface Token extends Node {
-        __tokenTag: any;
-    }
-    interface Modifier extends Token {
+    interface Modifier extends Node {
     }
     interface Identifier extends PrimaryExpression {
         text: string;
@@ -1738,6 +1735,7 @@ declare namespace ts {
         getCancellationToken?(): CancellationToken;
         getDefaultLibFileName(options: CompilerOptions): string;
         getDefaultLibLocation?(): string;
+        getDefaultTypeDirectiveNames?(rootPath: string): string[];
         writeFile: WriteFileCallback;
         getCurrentDirectory(): string;
         getDirectories(path: string): string[];
@@ -1883,6 +1881,8 @@ declare namespace ts {
     function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
     function getTypeParameterOwner(d: Declaration): Declaration;
     function isParameterPropertyDeclaration(node: ParameterDeclaration): boolean;
+    function startsWith(str: string, prefix: string): boolean;
+    function endsWith(str: string, suffix: string): boolean;
 }
 declare namespace ts {
     function createNode(kind: SyntaxKind, pos?: number, end?: number): Node;
@@ -1909,12 +1909,6 @@ declare namespace ts {
     function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
     function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
     function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
-    interface FormatDiagnosticsHost {
-        getCurrentDirectory(): string;
-        getCanonicalFileName(fileName: string): string;
-        getNewLine(): string;
-    }
-    function formatDiagnostics(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): string;
     function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
     /**
       * Given a set of options, returns the set of type directive names

package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "http://typescriptlang.org/",
-    "version": "2.0.5",
+    "version": "2.1.0",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -75,8 +75,9 @@
         "through2": "latest",
         "travis-fold": "latest",
         "ts-node": "latest",
-        "tslint": "3.15.1",
-        "typescript": "2.0.*"
+        "tsd": "latest",
+        "tslint": "next",
+        "typescript": "next"
     },
     "scripts": {
         "pretest": "jake tests",

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/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);
             }
         }
     }
@@ -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);
+            }
         }
     }
 }

src/compiler/binder.ts

@@ -28,7 +28,7 @@ namespace ts {
             return ModuleInstanceState.ConstEnumOnly;
         }
         // 3. non-exported import declarations
-        else if ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) && !(node.flags & NodeFlags.Export)) {
+        else if ((node.kind === SyntaxKind.ImportDeclaration || node.kind === SyntaxKind.ImportEqualsDeclaration) && !(hasModifier(node, ModifierFlags.Export))) {
             return ModuleInstanceState.NonInstantiated;
         }
         // 4. other uninstantiated module declarations.
@@ -132,6 +132,10 @@ namespace ts {
         const unreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };
         const reportedUnreachableFlow: FlowNode = { flags: FlowFlags.Unreachable };
 
+        // state used to aggregate transform flags during bind.
+        let subtreeTransformFlags: TransformFlags = TransformFlags.None;
+        let skipTransformFlagAggregation: boolean;
+
         function bindSourceFile(f: SourceFile, opts: CompilerOptions) {
             file = f;
             options = opts;
@@ -139,6 +143,7 @@ namespace ts {
             inStrictMode = !!file.externalModuleIndicator;
             classifiableNames = createMap<string>();
             symbolCount = 0;
+            skipTransformFlagAggregation = isDeclarationFile(file);
 
             Symbol = objectAllocator.getSymbolConstructor();
 
@@ -165,6 +170,7 @@ namespace ts {
             activeLabels = undefined;
             hasExplicitReturn = false;
             emitFlags = NodeFlags.None;
+            subtreeTransformFlags = TransformFlags.None;
         }
 
         return bindSourceFile;
@@ -254,7 +260,7 @@ namespace ts {
 
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.ClassDeclaration:
-                    return node.flags & NodeFlags.Default ? "default" : undefined;
+                    return hasModifier(node, ModifierFlags.Default) ? "default" : undefined;
                 case SyntaxKind.JSDocFunctionType:
                     return isJSDocConstructSignature(node) ? "__new" : "__call";
                 case SyntaxKind.Parameter:
@@ -263,7 +269,7 @@ namespace ts {
                     Debug.assert(node.parent.kind === SyntaxKind.JSDocFunctionType);
                     let functionType = <JSDocFunctionType>node.parent;
                     let index = indexOf(functionType.parameters, node);
-                    return "p" + index;
+                    return "arg" + index;
                 case SyntaxKind.JSDocTypedefTag:
                     const parentNode = node.parent && node.parent.parent;
                     let nameFromParentNode: string;
@@ -294,7 +300,7 @@ namespace ts {
         function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
             Debug.assert(!hasDynamicName(node));
 
-            const isDefaultExport = node.flags & NodeFlags.Default;
+            const isDefaultExport = hasModifier(node, ModifierFlags.Default);
 
             // The exported symbol for an export default function/class node is always named "default"
             const name = isDefaultExport && parent ? "default" : getDeclarationName(node);
@@ -351,7 +357,7 @@ namespace ts {
                             : Diagnostics.Duplicate_identifier_0;
 
                         forEach(symbol.declarations, declaration => {
-                            if (declaration.flags & NodeFlags.Default) {
+                            if (hasModifier(declaration, ModifierFlags.Default)) {
                                 message = Diagnostics.A_module_cannot_have_multiple_default_exports;
                             }
                         });
@@ -373,7 +379,7 @@ namespace ts {
         }
 
         function declareModuleMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {
-            const hasExportModifier = getCombinedNodeFlags(node) & NodeFlags.Export;
+            const hasExportModifier = getCombinedModifierFlags(node) & ModifierFlags.Export;
             if (symbolFlags & SymbolFlags.Alias) {
                 if (node.kind === SyntaxKind.ExportSpecifier || (node.kind === SyntaxKind.ImportEqualsDeclaration && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -514,13 +520,28 @@ namespace ts {
         }
 
         function bindChildren(node: Node): void {
+            if (skipTransformFlagAggregation) {
+                bindChildrenWorker(node);
+            }
+            else if (node.transformFlags & TransformFlags.HasComputedFlags) {
+                skipTransformFlagAggregation = true;
+                bindChildrenWorker(node);
+                skipTransformFlagAggregation = false;
+            }
+            else {
+                const savedSubtreeTransformFlags = subtreeTransformFlags;
+                subtreeTransformFlags = 0;
+                bindChildrenWorker(node);
+                subtreeTransformFlags = savedSubtreeTransformFlags | computeTransformFlagsForNode(node, subtreeTransformFlags);
+            }
+        }
+
+        function bindChildrenWorker(node: Node): void {
             // Binding of JsDocComment should be done before the current block scope container changes.
             // because the scope of JsDocComment should not be affected by whether the current node is a
             // container or not.
             if (isInJavaScriptFile(node) && node.jsDocComments) {
-                for (const jsDocComment of node.jsDocComments) {
-                    bind(jsDocComment);
-                }
+                forEach(node.jsDocComments, bind);
             }
             if (checkUnreachable(node)) {
                 forEachChild(node, bind);
@@ -569,6 +590,9 @@ namespace ts {
                 case SyntaxKind.PrefixUnaryExpression:
                     bindPrefixUnaryExpressionFlow(<PrefixUnaryExpression>node);
                     break;
+                case SyntaxKind.PostfixUnaryExpression:
+                    bindPostfixUnaryExpressionFlow(<PostfixUnaryExpression>node);
+                    break;
                 case SyntaxKind.BinaryExpression:
                     bindBinaryExpressionFlow(<BinaryExpression>node);
                     break;
@@ -1084,6 +1108,16 @@ namespace ts {
             }
             else {
                 forEachChild(node, bind);
+                if (node.operator === SyntaxKind.PlusEqualsToken || node.operator === SyntaxKind.MinusMinusToken) {
+                    bindAssignmentTargetFlow(node.operand);
+                }
+            }
+        }
+
+        function bindPostfixUnaryExpressionFlow(node: PostfixUnaryExpression) {
+            forEachChild(node, bind);
+            if (node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) {
+                bindAssignmentTargetFlow(node.operand);
             }
         }
 
@@ -1128,8 +1162,8 @@ namespace ts {
             currentFlow = finishFlowLabel(postExpressionLabel);
         }
 
-        function bindInitializedVariableFlow(node: VariableDeclaration | BindingElement) {
-            const name = node.name;
+        function bindInitializedVariableFlow(node: VariableDeclaration | ArrayBindingElement) {
+            const name = !isOmittedExpression(node) ? node.name : undefined;
             if (isBindingPattern(name)) {
                 for (const child of name.elements) {
                     bindInitializedVariableFlow(child);
@@ -1309,7 +1343,7 @@ namespace ts {
         }
 
         function declareClassMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags) {
-            return node.flags & NodeFlags.Static
+            return hasModifier(node, ModifierFlags.Static)
                 ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes)
                 : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
         }
@@ -1346,7 +1380,7 @@ namespace ts {
         function bindModuleDeclaration(node: ModuleDeclaration) {
             setExportContextFlag(node);
             if (isAmbientModule(node)) {
-                if (node.flags & NodeFlags.Export) {
+                if (hasModifier(node, ModifierFlags.Export)) {
                     errorOnFirstToken(node, Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
                 }
                 if (isExternalModuleAugmentation(node)) {
@@ -1613,7 +1647,7 @@ namespace ts {
             }
         }
 
-        function checkStrictModeNumericLiteral(node: LiteralExpression) {
+        function checkStrictModeNumericLiteral(node: NumericLiteral) {
             if (inStrictMode && node.isOctalLiteral) {
                 file.bindDiagnostics.push(createDiagnosticForNode(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
             }
@@ -1688,6 +1722,9 @@ namespace ts {
                 }
                 parent = saveParent;
             }
+            else if (!skipTransformFlagAggregation && (node.transformFlags & TransformFlags.HasComputedFlags) === 0) {
+                subtreeTransformFlags |= computeTransformFlagsForNode(node, 0);
+            }
             inStrictMode = saveInStrictMode;
         }
 
@@ -1758,7 +1795,7 @@ namespace ts {
                 case SyntaxKind.DeleteExpression:
                     return checkStrictModeDeleteExpression(<DeleteExpression>node);
                 case SyntaxKind.NumericLiteral:
-                    return checkStrictModeNumericLiteral(<LiteralExpression>node);
+                    return checkStrictModeNumericLiteral(<NumericLiteral>node);
                 case SyntaxKind.PostfixUnaryExpression:
                     return checkStrictModePostfixUnaryExpression(<PostfixUnaryExpression>node);
                 case SyntaxKind.PrefixUnaryExpression:
@@ -1790,7 +1827,7 @@ namespace ts {
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
 
                 case SyntaxKind.JsxSpreadAttribute:
-                    emitFlags |= NodeFlags.HasJsxSpreadAttribute;
+                    emitFlags |= NodeFlags.HasJsxSpreadAttributes;
                     return;
 
                 case SyntaxKind.CallSignature:
@@ -2205,7 +2242,7 @@ namespace ts {
             if (currentFlow === unreachableFlow) {
                 const reportError =
                     // report error on all statements except empty ones
-                    (isStatement(node) && node.kind !== SyntaxKind.EmptyStatement) ||
+                    (isStatementButNotDeclaration(node) && node.kind !== SyntaxKind.EmptyStatement) ||
                     // report error on class declarations
                     node.kind === SyntaxKind.ClassDeclaration ||
                     // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
@@ -2242,4 +2279,763 @@ namespace ts {
             return true;
         }
     }
+
+    /**
+     * Computes the transform flags for a node, given the transform flags of its subtree
+     *
+     * @param node The node to analyze
+     * @param subtreeFlags Transform flags computed for this node's subtree
+     */
+    export function computeTransformFlagsForNode(node: Node, subtreeFlags: TransformFlags): TransformFlags {
+        const kind = node.kind;
+        switch (kind) {
+            case SyntaxKind.CallExpression:
+                return computeCallExpression(<CallExpression>node, subtreeFlags);
+
+            case SyntaxKind.ModuleDeclaration:
+                return computeModuleDeclaration(<ModuleDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.ParenthesizedExpression:
+                return computeParenthesizedExpression(<ParenthesizedExpression>node, subtreeFlags);
+
+            case SyntaxKind.BinaryExpression:
+                return computeBinaryExpression(<BinaryExpression>node, subtreeFlags);
+
+            case SyntaxKind.ExpressionStatement:
+                return computeExpressionStatement(<ExpressionStatement>node, subtreeFlags);
+
+            case SyntaxKind.Parameter:
+                return computeParameter(<ParameterDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.ArrowFunction:
+                return computeArrowFunction(<ArrowFunction>node, subtreeFlags);
+
+            case SyntaxKind.FunctionExpression:
+                return computeFunctionExpression(<FunctionExpression>node, subtreeFlags);
+
+            case SyntaxKind.FunctionDeclaration:
+                return computeFunctionDeclaration(<FunctionDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.VariableDeclaration:
+                return computeVariableDeclaration(<VariableDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.VariableDeclarationList:
+                return computeVariableDeclarationList(<VariableDeclarationList>node, subtreeFlags);
+
+            case SyntaxKind.VariableStatement:
+                return computeVariableStatement(<VariableStatement>node, subtreeFlags);
+
+            case SyntaxKind.LabeledStatement:
+                return computeLabeledStatement(<LabeledStatement>node, subtreeFlags);
+
+            case SyntaxKind.ClassDeclaration:
+                return computeClassDeclaration(<ClassDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.ClassExpression:
+                return computeClassExpression(<ClassExpression>node, subtreeFlags);
+
+            case SyntaxKind.HeritageClause:
+                return computeHeritageClause(<HeritageClause>node, subtreeFlags);
+
+            case SyntaxKind.ExpressionWithTypeArguments:
+                return computeExpressionWithTypeArguments(<ExpressionWithTypeArguments>node, subtreeFlags);
+
+            case SyntaxKind.Constructor:
+                return computeConstructor(<ConstructorDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.PropertyDeclaration:
+                return computePropertyDeclaration(<PropertyDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.MethodDeclaration:
+                return computeMethod(<MethodDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+                return computeAccessor(<AccessorDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.ImportEqualsDeclaration:
+                return computeImportEquals(<ImportEqualsDeclaration>node, subtreeFlags);
+
+            case SyntaxKind.PropertyAccessExpression:
+                return computePropertyAccess(<PropertyAccessExpression>node, subtreeFlags);
+
+            default:
+                return computeOther(node, kind, subtreeFlags);
+        }
+    }
+
+    function computeCallExpression(node: CallExpression, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const expression = node.expression;
+        const expressionKind = expression.kind;
+
+        if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression
+            || isSuperOrSuperProperty(expression, expressionKind)) {
+            // If the this node contains a SpreadElementExpression, or is a super call, then it is an ES6
+            // node.
+            transformFlags |= TransformFlags.AssertES6;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ArrayLiteralOrCallOrNewExcludes;
+    }
+
+    function isSuperOrSuperProperty(node: Node, kind: SyntaxKind) {
+        switch (kind) {
+            case SyntaxKind.SuperKeyword:
+                return true;
+
+            case SyntaxKind.PropertyAccessExpression:
+            case SyntaxKind.ElementAccessExpression:
+                const expression = (<PropertyAccessExpression | ElementAccessExpression>node).expression;
+                const expressionKind = expression.kind;
+                return expressionKind === SyntaxKind.SuperKeyword;
+        }
+
+        return false;
+    }
+
+    function computeBinaryExpression(node: BinaryExpression, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const operatorTokenKind = node.operatorToken.kind;
+        const leftKind = node.left.kind;
+
+        if (operatorTokenKind === SyntaxKind.EqualsToken
+            && (leftKind === SyntaxKind.ObjectLiteralExpression
+                || leftKind === SyntaxKind.ArrayLiteralExpression)) {
+            // Destructuring assignments are ES6 syntax.
+            transformFlags |= TransformFlags.AssertES6 | TransformFlags.DestructuringAssignment;
+        }
+        else if (operatorTokenKind === SyntaxKind.AsteriskAsteriskToken
+            || operatorTokenKind === SyntaxKind.AsteriskAsteriskEqualsToken) {
+            // Exponentiation is ES7 syntax.
+            transformFlags |= TransformFlags.AssertES7;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeParameter(node: ParameterDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const modifierFlags = getModifierFlags(node);
+        const name = node.name;
+        const initializer = node.initializer;
+        const dotDotDotToken = node.dotDotDotToken;
+
+        // If the parameter has a question token, then it is TypeScript syntax.
+        if (node.questionToken) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        // If the parameter's name is 'this', then it is TypeScript syntax.
+        if (subtreeFlags & TransformFlags.ContainsDecorators
+            || (name && isIdentifier(name) && name.originalKeywordKind === SyntaxKind.ThisKeyword)) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        // If a parameter has an accessibility modifier, then it is TypeScript syntax.
+        if (modifierFlags & ModifierFlags.ParameterPropertyModifier) {
+            transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsParameterPropertyAssignments;
+        }
+
+        // If a parameter has an initializer, a binding pattern or a dotDotDot token, then
+        // it is ES6 syntax and its container must emit default value assignments or parameter destructuring downlevel.
+        if (subtreeFlags & TransformFlags.ContainsBindingPattern || initializer || dotDotDotToken) {
+            transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsDefaultValueAssignments;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ParameterExcludes;
+    }
+
+    function computeParenthesizedExpression(node: ParenthesizedExpression, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const expression = node.expression;
+        const expressionKind = expression.kind;
+        const expressionTransformFlags = expression.transformFlags;
+
+        // If the node is synthesized, it means the emitter put the parentheses there,
+        // not the user. If we didn't want them, the emitter would not have put them
+        // there.
+        if (expressionKind === SyntaxKind.AsExpression
+            || expressionKind === SyntaxKind.TypeAssertionExpression) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        // If the expression of a ParenthesizedExpression is a destructuring assignment,
+        // then the ParenthesizedExpression is a destructuring assignment.
+        if (expressionTransformFlags & TransformFlags.DestructuringAssignment) {
+            transformFlags |= TransformFlags.DestructuringAssignment;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeClassDeclaration(node: ClassDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags: TransformFlags;
+        const modifierFlags = getModifierFlags(node);
+
+        if (modifierFlags & ModifierFlags.Ambient) {
+            // An ambient declaration is TypeScript syntax.
+            transformFlags = TransformFlags.AssertTypeScript;
+        }
+        else {
+            // A ClassDeclaration is ES6 syntax.
+            transformFlags = subtreeFlags | TransformFlags.AssertES6;
+
+            // A class with a parameter property assignment, property initializer, or decorator is
+            // TypeScript syntax.
+            // An exported declaration may be TypeScript syntax.
+            if ((subtreeFlags & TransformFlags.TypeScriptClassSyntaxMask)
+                || (modifierFlags & ModifierFlags.Export)) {
+                transformFlags |= TransformFlags.AssertTypeScript;
+            }
+
+            if (subtreeFlags & TransformFlags.ContainsLexicalThisInComputedPropertyName) {
+                // A computed property name containing `this` might need to be rewritten,
+                // so propagate the ContainsLexicalThis flag upward.
+                transformFlags |= TransformFlags.ContainsLexicalThis;
+            }
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ClassExcludes;
+    }
+
+    function computeClassExpression(node: ClassExpression, subtreeFlags: TransformFlags) {
+        // A ClassExpression is ES6 syntax.
+        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+
+        // A class with a parameter property assignment, property initializer, or decorator is
+        // TypeScript syntax.
+        if (subtreeFlags & TransformFlags.TypeScriptClassSyntaxMask) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        if (subtreeFlags & TransformFlags.ContainsLexicalThisInComputedPropertyName) {
+            // A computed property name containing `this` might need to be rewritten,
+            // so propagate the ContainsLexicalThis flag upward.
+            transformFlags |= TransformFlags.ContainsLexicalThis;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ClassExcludes;
+    }
+
+    function computeHeritageClause(node: HeritageClause, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+
+        switch (node.token) {
+            case SyntaxKind.ExtendsKeyword:
+                // An `extends` HeritageClause is ES6 syntax.
+                transformFlags |= TransformFlags.AssertES6;
+                break;
+
+            case SyntaxKind.ImplementsKeyword:
+                // An `implements` HeritageClause is TypeScript syntax.
+                transformFlags |= TransformFlags.AssertTypeScript;
+                break;
+
+            default:
+                Debug.fail("Unexpected token for heritage clause");
+                break;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeExpressionWithTypeArguments(node: ExpressionWithTypeArguments, subtreeFlags: TransformFlags) {
+        // An ExpressionWithTypeArguments is ES6 syntax, as it is used in the
+        // extends clause of a class.
+        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+
+        // If an ExpressionWithTypeArguments contains type arguments, then it
+        // is TypeScript syntax.
+        if (node.typeArguments) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeConstructor(node: ConstructorDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const body = node.body;
+
+        if (body === undefined) {
+            // An overload constructor is TypeScript syntax.
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ConstructorExcludes;
+    }
+
+    function computeMethod(node: MethodDeclaration, subtreeFlags: TransformFlags) {
+        // A MethodDeclaration is ES6 syntax.
+        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+        const modifierFlags = getModifierFlags(node);
+        const body = node.body;
+        const typeParameters = node.typeParameters;
+        const asteriskToken = node.asteriskToken;
+
+        // A MethodDeclaration is TypeScript syntax if it is either async, abstract, overloaded,
+        // generic, or has a decorator.
+        if (!body
+            || typeParameters
+            || (modifierFlags & (ModifierFlags.Async | ModifierFlags.Abstract))
+            || (subtreeFlags & TransformFlags.ContainsDecorators)) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        // Currently, we only support generators that were originally async function bodies.
+        if (asteriskToken && node.emitFlags & NodeEmitFlags.AsyncFunctionBody) {
+            transformFlags |= TransformFlags.AssertGenerator;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.MethodOrAccessorExcludes;
+    }
+
+    function computeAccessor(node: AccessorDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const modifierFlags = getModifierFlags(node);
+        const body = node.body;
+
+        // A MethodDeclaration is TypeScript syntax if it is either async, abstract, overloaded,
+        // generic, or has a decorator.
+        if (!body
+            || (modifierFlags & (ModifierFlags.Async | ModifierFlags.Abstract))
+            || (subtreeFlags & TransformFlags.ContainsDecorators)) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.MethodOrAccessorExcludes;
+    }
+
+    function computePropertyDeclaration(node: PropertyDeclaration, subtreeFlags: TransformFlags) {
+        // A PropertyDeclaration is TypeScript syntax.
+        let transformFlags = subtreeFlags | TransformFlags.AssertTypeScript;
+
+        // If the PropertyDeclaration has an initializer, we need to inform its ancestor
+        // so that it handle the transformation.
+        if (node.initializer) {
+            transformFlags |= TransformFlags.ContainsPropertyInitializer;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeFunctionDeclaration(node: FunctionDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags: TransformFlags;
+        const modifierFlags = getModifierFlags(node);
+        const body = node.body;
+        const asteriskToken = node.asteriskToken;
+
+        if (!body || (modifierFlags & ModifierFlags.Ambient)) {
+            // An ambient declaration is TypeScript syntax.
+            // A FunctionDeclaration without a body is an overload and is TypeScript syntax.
+            transformFlags = TransformFlags.AssertTypeScript;
+        }
+        else {
+            transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclarationOrCompletion;
+
+            // If a FunctionDeclaration is exported, then it is either ES6 or TypeScript syntax.
+            if (modifierFlags & ModifierFlags.Export) {
+                transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.AssertES6;
+            }
+
+            // If a FunctionDeclaration is async, then it is TypeScript syntax.
+            if (modifierFlags & ModifierFlags.Async) {
+                transformFlags |= TransformFlags.AssertTypeScript;
+            }
+
+            // If a FunctionDeclaration's subtree has marked the container as needing to capture the
+            // lexical this, or the function contains parameters with initializers, then this node is
+            // ES6 syntax.
+            if (subtreeFlags & TransformFlags.ES6FunctionSyntaxMask) {
+                transformFlags |= TransformFlags.AssertES6;
+            }
+
+            // If a FunctionDeclaration is generator function and is the body of a
+            // transformed async function, then this node can be transformed to a
+            // down-level generator.
+            // Currently we do not support transforming any other generator fucntions
+            // down level.
+            if (asteriskToken && node.emitFlags & NodeEmitFlags.AsyncFunctionBody) {
+                transformFlags |= TransformFlags.AssertGenerator;
+            }
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.FunctionExcludes;
+    }
+
+    function computeFunctionExpression(node: FunctionExpression, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const modifierFlags = getModifierFlags(node);
+        const asteriskToken = node.asteriskToken;
+
+        // An async function expression is TypeScript syntax.
+        if (modifierFlags & ModifierFlags.Async) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        // If a FunctionExpression's subtree has marked the container as needing to capture the
+        // lexical this, or the function contains parameters with initializers, then this node is
+        // ES6 syntax.
+        if (subtreeFlags & TransformFlags.ES6FunctionSyntaxMask) {
+            transformFlags |= TransformFlags.AssertES6;
+        }
+
+        // If a FunctionExpression is generator function and is the body of a
+        // transformed async function, then this node can be transformed to a
+        // down-level generator.
+        // Currently we do not support transforming any other generator fucntions
+        // down level.
+        if (asteriskToken && node.emitFlags & NodeEmitFlags.AsyncFunctionBody) {
+            transformFlags |= TransformFlags.AssertGenerator;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.FunctionExcludes;
+    }
+
+    function computeArrowFunction(node: ArrowFunction, subtreeFlags: TransformFlags) {
+        // An ArrowFunction is ES6 syntax, and excludes markers that should not escape the scope of an ArrowFunction.
+        let transformFlags = subtreeFlags | TransformFlags.AssertES6;
+        const modifierFlags = getModifierFlags(node);
+
+        // An async arrow function is TypeScript syntax.
+        if (modifierFlags & ModifierFlags.Async) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        // If an ArrowFunction contains a lexical this, its container must capture the lexical this.
+        if (subtreeFlags & TransformFlags.ContainsLexicalThis) {
+            transformFlags |= TransformFlags.ContainsCapturedLexicalThis;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ArrowFunctionExcludes;
+    }
+
+    function computePropertyAccess(node: PropertyAccessExpression, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const expression = node.expression;
+        const expressionKind = expression.kind;
+
+        // If a PropertyAccessExpression starts with a super keyword, then it is
+        // ES6 syntax, and requires a lexical `this` binding.
+        if (expressionKind === SyntaxKind.SuperKeyword) {
+            transformFlags |= TransformFlags.ContainsLexicalThis;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeVariableDeclaration(node: VariableDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+        const nameKind = node.name.kind;
+
+        // A VariableDeclaration with a binding pattern is ES6 syntax.
+        if (nameKind === SyntaxKind.ObjectBindingPattern || nameKind === SyntaxKind.ArrayBindingPattern) {
+            transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBindingPattern;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeVariableStatement(node: VariableStatement, subtreeFlags: TransformFlags) {
+        let transformFlags: TransformFlags;
+        const modifierFlags = getModifierFlags(node);
+        const declarationListTransformFlags = node.declarationList.transformFlags;
+
+        // An ambient declaration is TypeScript syntax.
+        if (modifierFlags & ModifierFlags.Ambient) {
+            transformFlags = TransformFlags.AssertTypeScript;
+        }
+        else {
+            transformFlags = subtreeFlags;
+
+            // If a VariableStatement is exported, then it is either ES6 or TypeScript syntax.
+            if (modifierFlags & ModifierFlags.Export) {
+                transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
+            }
+
+            if (declarationListTransformFlags & TransformFlags.ContainsBindingPattern) {
+                transformFlags |= TransformFlags.AssertES6;
+            }
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeLabeledStatement(node: LabeledStatement, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+
+        // A labeled statement containing a block scoped binding *may* need to be transformed from ES6.
+        if (subtreeFlags & TransformFlags.ContainsBlockScopedBinding
+            && isIterationStatement(node, /*lookInLabeledStatements*/ true)) {
+            transformFlags |= TransformFlags.AssertES6;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeImportEquals(node: ImportEqualsDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+
+        // An ImportEqualsDeclaration with a namespace reference is TypeScript.
+        if (!isExternalModuleImportEqualsDeclaration(node)) {
+            transformFlags |= TransformFlags.AssertTypeScript;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeExpressionStatement(node: ExpressionStatement, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags;
+
+        // If the expression of an expression statement is a destructuring assignment,
+        // then we treat the statement as ES6 so that we can indicate that we do not
+        // need to hold on to the right-hand side.
+        if (node.expression.transformFlags & TransformFlags.DestructuringAssignment) {
+            transformFlags |= TransformFlags.AssertES6;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.NodeExcludes;
+    }
+
+    function computeModuleDeclaration(node: ModuleDeclaration, subtreeFlags: TransformFlags) {
+        let transformFlags = TransformFlags.AssertTypeScript;
+        const modifierFlags = getModifierFlags(node);
+
+        if ((modifierFlags & ModifierFlags.Ambient) === 0) {
+            transformFlags |= subtreeFlags;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.ModuleExcludes;
+    }
+
+    function computeVariableDeclarationList(node: VariableDeclarationList, subtreeFlags: TransformFlags) {
+        let transformFlags = subtreeFlags | TransformFlags.ContainsHoistedDeclarationOrCompletion;
+
+        if (subtreeFlags & TransformFlags.ContainsBindingPattern) {
+            transformFlags |= TransformFlags.AssertES6;
+        }
+
+        // If a VariableDeclarationList is `let` or `const`, then it is ES6 syntax.
+        if (node.flags & NodeFlags.BlockScoped) {
+            transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBlockScopedBinding;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~TransformFlags.VariableDeclarationListExcludes;
+    }
+
+    function computeOther(node: Node, kind: SyntaxKind, subtreeFlags: TransformFlags) {
+        // Mark transformations needed for each node
+        let transformFlags = subtreeFlags;
+        let excludeFlags = TransformFlags.NodeExcludes;
+
+        switch (kind) {
+            case SyntaxKind.PublicKeyword:
+            case SyntaxKind.PrivateKeyword:
+            case SyntaxKind.ProtectedKeyword:
+            case SyntaxKind.AbstractKeyword:
+            case SyntaxKind.DeclareKeyword:
+            case SyntaxKind.AsyncKeyword:
+            case SyntaxKind.ConstKeyword:
+            case SyntaxKind.AwaitExpression:
+            case SyntaxKind.EnumDeclaration:
+            case SyntaxKind.EnumMember:
+            case SyntaxKind.TypeAssertionExpression:
+            case SyntaxKind.AsExpression:
+            case SyntaxKind.NonNullExpression:
+            case SyntaxKind.ReadonlyKeyword:
+                // These nodes are TypeScript syntax.
+                transformFlags |= TransformFlags.AssertTypeScript;
+                break;
+
+            case SyntaxKind.JsxElement:
+            case SyntaxKind.JsxSelfClosingElement:
+            case SyntaxKind.JsxOpeningElement:
+            case SyntaxKind.JsxText:
+            case SyntaxKind.JsxClosingElement:
+            case SyntaxKind.JsxAttribute:
+            case SyntaxKind.JsxSpreadAttribute:
+            case SyntaxKind.JsxExpression:
+                // These nodes are Jsx syntax.
+                transformFlags |= TransformFlags.AssertJsx;
+                break;
+
+            case SyntaxKind.ExportKeyword:
+                // This node is both ES6 and TypeScript syntax.
+                transformFlags |= TransformFlags.AssertES6 | TransformFlags.AssertTypeScript;
+                break;
+
+            case SyntaxKind.DefaultKeyword:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+            case SyntaxKind.TemplateHead:
+            case SyntaxKind.TemplateMiddle:
+            case SyntaxKind.TemplateTail:
+            case SyntaxKind.TemplateExpression:
+            case SyntaxKind.TaggedTemplateExpression:
+            case SyntaxKind.ShorthandPropertyAssignment:
+            case SyntaxKind.ForOfStatement:
+                // These nodes are ES6 syntax.
+                transformFlags |= TransformFlags.AssertES6;
+                break;
+
+            case SyntaxKind.YieldExpression:
+                // This node is ES6 syntax.
+                transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsYield;
+                break;
+
+            case SyntaxKind.AnyKeyword:
+            case SyntaxKind.NumberKeyword:
+            case SyntaxKind.NeverKeyword:
+            case SyntaxKind.StringKeyword:
+            case SyntaxKind.BooleanKeyword:
+            case SyntaxKind.SymbolKeyword:
+            case SyntaxKind.VoidKeyword:
+            case SyntaxKind.TypeParameter:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.MethodSignature:
+            case SyntaxKind.CallSignature:
+            case SyntaxKind.ConstructSignature:
+            case SyntaxKind.IndexSignature:
+            case SyntaxKind.TypePredicate:
+            case SyntaxKind.TypeReference:
+            case SyntaxKind.FunctionType:
+            case SyntaxKind.ConstructorType:
+            case SyntaxKind.TypeQuery:
+            case SyntaxKind.TypeLiteral:
+            case SyntaxKind.ArrayType:
+            case SyntaxKind.TupleType:
+            case SyntaxKind.UnionType:
+            case SyntaxKind.IntersectionType:
+            case SyntaxKind.ParenthesizedType:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind.ThisType:
+            case SyntaxKind.LiteralType:
+                // Types and signatures are TypeScript syntax, and exclude all other facts.
+                transformFlags = TransformFlags.AssertTypeScript;
+                excludeFlags = TransformFlags.TypeExcludes;
+                break;
+
+            case SyntaxKind.ComputedPropertyName:
+                // Even though computed property names are ES6, we don't treat them as such.
+                // This is so that they can flow through PropertyName transforms unaffected.
+                // Instead, we mark the container as ES6, so that it can properly handle the transform.
+                transformFlags |= TransformFlags.ContainsComputedPropertyName;
+                if (subtreeFlags & TransformFlags.ContainsLexicalThis) {
+                    // A computed method name like `[this.getName()](x: string) { ... }` needs to
+                    // distinguish itself from the normal case of a method body containing `this`:
+                    // `this` inside a method doesn't need to be rewritten (the method provides `this`),
+                    // whereas `this` inside a computed name *might* need to be rewritten if the class/object
+                    // is inside an arrow function:
+                    // `_this = this; () => class K { [_this.getName()]() { ... } }`
+                    // To make this distinction, use ContainsLexicalThisInComputedPropertyName
+                    // instead of ContainsLexicalThis for computed property names
+                    transformFlags |= TransformFlags.ContainsLexicalThisInComputedPropertyName;
+                }
+                break;
+
+            case SyntaxKind.SpreadElementExpression:
+                // This node is ES6 syntax, but is handled by a containing node.
+                transformFlags |= TransformFlags.ContainsSpreadElementExpression;
+                break;
+
+            case SyntaxKind.SuperKeyword:
+                // This node is ES6 syntax.
+                transformFlags |= TransformFlags.AssertES6;
+                break;
+
+            case SyntaxKind.ThisKeyword:
+                // Mark this node and its ancestors as containing a lexical `this` keyword.
+                transformFlags |= TransformFlags.ContainsLexicalThis;
+                break;
+
+            case SyntaxKind.ObjectBindingPattern:
+            case SyntaxKind.ArrayBindingPattern:
+                // These nodes are ES6 syntax.
+                transformFlags |= TransformFlags.AssertES6 | TransformFlags.ContainsBindingPattern;
+                break;
+
+            case SyntaxKind.Decorator:
+                // This node is TypeScript syntax, and marks its container as also being TypeScript syntax.
+                transformFlags |= TransformFlags.AssertTypeScript | TransformFlags.ContainsDecorators;
+                break;
+
+            case SyntaxKind.ObjectLiteralExpression:
+                excludeFlags = TransformFlags.ObjectLiteralExcludes;
+                if (subtreeFlags & TransformFlags.ContainsComputedPropertyName) {
+                    // If an ObjectLiteralExpression contains a ComputedPropertyName, then it
+                    // is an ES6 node.
+                    transformFlags |= TransformFlags.AssertES6;
+                }
+
+                if (subtreeFlags & TransformFlags.ContainsLexicalThisInComputedPropertyName) {
+                    // A computed property name containing `this` might need to be rewritten,
+                    // so propagate the ContainsLexicalThis flag upward.
+                    transformFlags |= TransformFlags.ContainsLexicalThis;
+                }
+
+                break;
+
+            case SyntaxKind.ArrayLiteralExpression:
+            case SyntaxKind.NewExpression:
+                excludeFlags = TransformFlags.ArrayLiteralOrCallOrNewExcludes;
+                if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
+                    // If the this node contains a SpreadElementExpression, then it is an ES6
+                    // node.
+                    transformFlags |= TransformFlags.AssertES6;
+                }
+
+                break;
+
+            case SyntaxKind.DoStatement:
+            case SyntaxKind.WhileStatement:
+            case SyntaxKind.ForStatement:
+            case SyntaxKind.ForInStatement:
+                // A loop containing a block scoped binding *may* need to be transformed from ES6.
+                if (subtreeFlags & TransformFlags.ContainsBlockScopedBinding) {
+                    transformFlags |= TransformFlags.AssertES6;
+                }
+
+                break;
+
+            case SyntaxKind.SourceFile:
+                if (subtreeFlags & TransformFlags.ContainsCapturedLexicalThis) {
+                    transformFlags |= TransformFlags.AssertES6;
+                }
+
+                break;
+
+            case SyntaxKind.ReturnStatement:
+            case SyntaxKind.ContinueStatement:
+            case SyntaxKind.BreakStatement:
+                transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion;
+                break;
+        }
+
+        node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
+        return transformFlags & ~excludeFlags;
+    }
 }

src/compiler/commandLineParser.ts

@@ -33,6 +33,7 @@ namespace ts {
         {
             name: "extendedDiagnostics",
             type: "boolean",
+            experimental: true
         },
         {
             name: "emitBOM",
@@ -296,6 +297,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",
@@ -436,6 +438,11 @@ namespace ts {
             name: "strictNullChecks",
             type: "boolean",
             description: Diagnostics.Enable_strict_null_checks
+        },
+        {
+            name: "importHelpers",
+            type: "boolean",
+            description: Diagnostics.Import_emit_helpers_from_tslib
         }
     ];
 
@@ -802,12 +809,45 @@ 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);
@@ -823,6 +863,39 @@ namespace ts {
             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")) {
@@ -857,14 +930,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) {

src/compiler/comments.ts

@@ -0,0 +1,352 @@
+/// <reference path="sourcemap.ts" />
+
+/* @internal */
+namespace ts {
+    export interface CommentWriter {
+        reset(): void;
+        setSourceFile(sourceFile: SourceFile): void;
+        emitNodeWithComments(node: Node, emitCallback: (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(node: Node, emitCallback: (node: Node) => void) {
+            if (disabled) {
+                emitCallback(node);
+                return;
+            }
+
+            if (node) {
+                const { pos, end } = node.commentRange || node;
+                const emitFlags = node.emitFlags;
+                if ((pos < 0 && end < 0) || (pos === end)) {
+                    // Both pos and end are synthesized, so just emit the node without comments.
+                    if (emitFlags & NodeEmitFlags.NoNestedComments) {
+                        disableCommentsAndEmit(node, emitCallback);
+                    }
+                    else {
+                        emitCallback(node);
+                    }
+                }
+                else {
+                    if (extendedDiagnostics) {
+                        performance.mark("preEmitNodeWithComment");
+                    }
+
+                    const isEmittedNode = node.kind !== SyntaxKind.NotEmittedStatement;
+                    const skipLeadingComments = pos < 0 || (emitFlags & NodeEmitFlags.NoLeadingComments) !== 0;
+                    const skipTrailingComments = end < 0 || (emitFlags & NodeEmitFlags.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 & NodeEmitFlags.NoNestedComments) {
+                        disableCommentsAndEmit(node, emitCallback);
+                    }
+                    else {
+                        emitCallback(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 = node.emitFlags;
+            const skipLeadingComments = pos < 0 || (emitFlags & NodeEmitFlags.NoLeadingComments) !== 0;
+            const skipTrailingComments = disabled || end < 0 || (emitFlags & NodeEmitFlags.NoTrailingComments) !== 0;
+
+            if (!skipLeadingComments) {
+                emitDetachedCommentsAndUpdateCommentsInfo(detachedRange);
+            }
+
+            if (extendedDiagnostics) {
+                performance.measure("commentTime", "preEmitBodyWithDetachedComments");
+            }
+
+            if (emitFlags & NodeEmitFlags.NoNestedComments) {
+                disableCommentsAndEmit(node, emitCallback);
+            }
+            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 disableCommentsAndEmit(node: Node, emitCallback: (node: Node) => void): void {
+            if (disabled) {
+                emitCallback(node);
+            }
+            else {
+                disabled = true;
+                emitCallback(node);
+                disabled = false;
+            }
+        }
+
+        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

@@ -121,6 +121,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++) {
@@ -177,11 +194,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++;
                 }
             }
@@ -193,6 +211,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;
@@ -240,12 +260,140 @@ 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 (let i = 0; i < array.length; i++) {
+                const v = array[i];
+                result.push(f(v, i));
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 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) {
-                result.push(f(v));
+                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;
@@ -254,8 +402,7 @@ namespace ts {
     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.
@@ -275,6 +422,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) {
@@ -286,7 +454,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);
+                }
             }
         }
     }
@@ -301,15 +471,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;
     }
 
     /**
@@ -348,14 +534,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++;
@@ -363,23 +550,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--;
@@ -387,11 +576,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;
@@ -480,6 +669,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.
      *
@@ -555,6 +756,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);
@@ -582,6 +792,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.
      */
@@ -820,7 +1060,8 @@ namespace ts {
         return 0;
     }
 
-    export let directorySeparator = "/";
+    export const directorySeparator = "/";
+    const directorySeparatorCharCode = CharacterCodes.slash;
     function getNormalizedParts(normalizedSlashedPath: string, rootLength: number) {
         const parts = normalizedSlashedPath.substr(rootLength).split(directorySeparator);
         const normalized: string[] = [];
@@ -845,8 +1086,20 @@ 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;
     }
 
     export function getDirectoryPath(path: Path): Path;
@@ -859,10 +1112,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.ES6 ? ModuleKind.ES6 : 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);
@@ -1477,11 +1769,16 @@ 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;
+        this.transformId = 0;
     }
 
     export let objectAllocator: ObjectAllocator = {
@@ -1502,10 +1799,13 @@ namespace ts {
     }
 
     export namespace Debug {
-        const currentAssertionLevel = AssertionLevel.None;
+        declare var process: any;
+        declare var require: any;
+
+        let currentAssertionLevel: AssertionLevel;
 
         export function shouldAssert(level: AssertionLevel): boolean {
-            return currentAssertionLevel >= level;
+            return getCurrentAssertionLevel() >= level;
         }
 
         export function assert(expression: boolean, message?: string, verboseDebugInfo?: () => string): void {
@@ -1522,97 +1822,76 @@ namespace ts {
         export function fail(message?: string): void {
             Debug.assert(/*expression*/ false, message);
         }
+
+        function getCurrentAssertionLevel() {
+            if (currentAssertionLevel !== undefined) {
+                return currentAssertionLevel;
+            }
+
+            if (sys === undefined) {
+                return AssertionLevel.None;
+            }
+
+            const developmentMode = /^development$/i.test(getEnvironmentVariable("NODE_ENV"));
+            currentAssertionLevel = developmentMode
+                ? AssertionLevel.Normal
+                : AssertionLevel.None;
+
+            return currentAssertionLevel;
+        }
     }
 
-    export function copyListRemovingItem<T>(item: T, list: T[]) {
-        const copiedList: T[] = [];
-        for (const e of list) {
-            if (e !== item) {
-                copiedList.push(e);
+    export function getEnvironmentVariable(name: string, host?: CompilerHost) {
+        if (host && host.getEnvironmentVariable) {
+            return host.getEnvironmentVariable(name);
+        }
+
+        if (sys && sys.getEnvironmentVariable) {
+            return sys.getEnvironmentVariable(name);
+        }
+
+        return "";
+    }
+
+    /** 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];
+        }
+        array.pop();
+    }
+
+    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;
             }
         }
-        return copiedList;
     }
 
-    export function createGetCanonicalFileName(useCaseSensitivefileNames: boolean): (fileName: string) => string {
-        return useCaseSensitivefileNames
+    export function createGetCanonicalFileName(useCaseSensitiveFileNames: boolean): (fileName: string) => string {
+        return useCaseSensitiveFileNames
             ? ((fileName) => fileName)
             : ((fileName) => fileName.toLowerCase());
     }
 
-
-    /* @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 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;
-    }
-
-    /* @internal */
-    export function createResolvedModule(resolvedFileName: string, isExternalLibraryImport: boolean, failedLookupLocations: string[]): ResolvedModuleWithFailedLookupLocations {
-        return { resolvedModule: resolvedFileName ? { resolvedFileName, isExternalLibraryImport } : undefined, failedLookupLocations };
-    }
-
-    /* @internal */
-    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);
-    }
-
-    /* @internal */
-    export interface ModuleResolutionState {
-        host: ModuleResolutionHost;
-        compilerOptions: CompilerOptions;
-        traceEnabled: boolean;
-        // skip .tsx files if jsx is not enabled
-        skipTsx: boolean;
-    }
-
-
-
-    /* @internal */
-    export 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 {};
-        }
-    }
-
-    /* @internal */
-    export function getEmitModuleKind(compilerOptions: CompilerOptions) {
-        return typeof compilerOptions.module === "number" ?
-            compilerOptions.module :
-            getEmitScriptTarget(compilerOptions) === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.CommonJS;
-    }
-
-    /* @internal */
-    export function getEmitScriptTarget(compilerOptions: CompilerOptions) {
-        return compilerOptions.target || ScriptTarget.ES3;
+    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

@@ -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));
         }
 
@@ -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);
             }
         }
 
@@ -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) {
@@ -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,7 +1115,7 @@ namespace ts {
             }
 
             emitJsDocComments(node);
-            emitClassMemberDeclarationFlags(node.flags);
+            emitClassMemberDeclarationFlags(getModifierFlags(node));
             emitVariableDeclaration(<VariableDeclaration>node);
             write(";");
             writeLine();
@@ -1141,7 +1142,7 @@ namespace ts {
                     if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {
                         emitTypeOfVariableDeclarationFromTypeLiteral(node);
                     }
-                    else if (!(node.flags & NodeFlags.Private)) {
+                    else if (!hasModifier(node, ModifierFlags.Private)) {
                         writeTypeOfDeclaration(node, node.type, getVariableDeclarationTypeVisibilityError);
                     }
                 }
@@ -1158,7 +1159,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 :
@@ -1269,9 +1270,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) {
@@ -1302,7 +1303,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;
@@ -1320,7 +1321,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 :
@@ -1356,7 +1357,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 ");
@@ -1387,7 +1388,7 @@ namespace ts {
 
             if (node.kind === SyntaxKind.IndexSignature) {
                 // Index signature can have readonly modifier
-                emitClassMemberDeclarationFlags(node.flags);
+                emitClassMemberDeclarationFlags(getModifierFlags(node));
                 write("[");
             }
             else {
@@ -1428,7 +1429,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);
             }
 
@@ -1468,7 +1469,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 :
@@ -1534,7 +1535,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);
             }
 
@@ -1570,7 +1571,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 :

src/compiler/diagnosticMessages.json

@@ -827,10 +827,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 +1043,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 +1063,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
@@ -1635,10 +1627,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 +1691,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
     },
@@ -1959,6 +1947,23 @@
         "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
+    },
+
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2476,6 +2481,10 @@
         "category": "Message",
         "code": 6038
     },
+    "STRATEGY": {
+        "category": "Message",
+        "code": 6039
+    },
     "Compilation complete. Watching for file changes.": {
         "category": "Message",
         "code": 6042
@@ -2840,9 +2849,13 @@
         "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": 6139
+        "code": 6140
     },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
@@ -2875,7 +2888,7 @@
     "Element implicitly has an 'any' type because index expression is not of type 'number'.": {
         "category": "Error",
         "code": 7015
-    }, 
+    },
     "Index signature of object type implicitly has an 'any' type.": {
         "category": "Error",
         "code": 7017
@@ -3051,5 +3064,14 @@
     "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
     }
 }

src/compiler/moduleNameResolver.ts

@@ -2,6 +2,36 @@
 /// <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);
 
@@ -39,233 +69,323 @@ namespace ts {
         return undefined;
     }
 
-    /** 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;
+    function readJson(path: string, host: ModuleResolutionHost): { typings?: string, types?: string, main?: string } {
+        try {
+            const jsonText = host.readFile(path);
+            return jsonText ? JSON.parse(jsonText) : {};
         }
-        else {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
-            }
-            failedLookupLocation.push(fileName);
-            return undefined;
+        catch (e) {
+            // gracefully handle if readFile fails or returns not JSON
+            return {};
         }
     }
 
-    /** 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);
-            }
+    const typeReferenceExtensions = [".d.ts"];
+
+    export function getEffectiveTypeRoots(options: CompilerOptions, host: { directoryExists?: (directoryName: string) => boolean, getCurrentDirectory?: () => string }): string[] | undefined {
+        if (options.typeRoots) {
+            return options.typeRoots;
         }
-        return forEach(extensions, ext =>
-            !(state.skipTsx && isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state));
+
+        let currentDirectory: string;
+        if (options.configFilePath) {
+            currentDirectory = getDirectoryPath(options.configFilePath);
+        }
+        else if (host.getCurrentDirectory) {
+            currentDirectory = host.getCurrentDirectory();
+        }
+
+        return currentDirectory && getDefaultTypeRoots(currentDirectory, host);
     }
 
     /**
-     * @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.
+     * Returns the path to every node_modules/@types directory from some ancestor directory.
+     * Returns undefined if there are none.
      */
-    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;
+    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.
         }
 
-        // 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);
+        let typeRoots: string[];
+
+        while (true) {
+            const atTypes = combinePaths(currentDirectory, nodeModulesAtTypes);
+            if (host.directoryExists(atTypes)) {
+                (typeRoots || (typeRoots = [])).push(atTypes);
             }
-            return tryAddingExtensions(extensionless, extensions, failedLookupLocation, onlyRecordFailures, state);
+
+            const parent = getDirectoryPath(currentDirectory);
+            if (parent === currentDirectory) {
+                break;
+            }
+            currentDirectory = parent;
         }
+
+        return typeRoots;
     }
+    const nodeModulesAtTypes = combinePaths("node_modules", "@types");
 
-    /* @internal */
-    export 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);
+    /**
+     * @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
+        };
 
-                if (result) {
-                    return result;
+        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 (state.traceEnabled) {
-                    trace(state.host, Diagnostics.package_json_does_not_have_types_field);
+                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 (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_does_not_exist, packageJsonPath);
+            if (traceEnabled) {
+                trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
             }
-            // 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 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;
+        let resolvedFile: string;
+        let initialLocationForSecondaryLookup: string;
+        if (containingFile) {
+            initialLocationForSecondaryLookup = getDirectoryPath(containingFile);
         }
-        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 {
-        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;
+        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 {
-                    // 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;
+                    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));
+                            }
+                        }
                     }
                 }
             }
-
-            const parentPath = getDirectoryPath(directory);
-            if (parentPath === directory || checkOneLevel) {
-                break;
-            }
-
-            directory = parentPath;
         }
-        return undefined;
+        return result;
     }
 
-    function moduleHasNonRelativeName(moduleName: string): boolean {
-        return !(isRootedDiskPath(moduleName) || isExternalModuleNameRelative(moduleName));
-    }
-
-    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+    export function resolveModuleName(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);
+        if (traceEnabled) {
+            trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
         }
 
-        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;
+        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 {
-            const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-            referencedSourceFile = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+            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;
+        }
 
-        return referencedSourceFile
-            ? { resolvedModule: { resolvedFileName: referencedSourceFile }, failedLookupLocations }
-            : { resolvedModule: undefined, failedLookupLocations };
-    }
-
-    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;
+        if (traceEnabled) {
+            if (result.resolvedModule) {
+                trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
             }
             else {
-                const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-                resolvedFileName = nodeLoadModuleByRelativeName(candidate, supportedExtensions, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+                trace(host, Diagnostics.Module_name_0_was_not_resolved, moduleName);
             }
         }
 
-        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);
+        return result;
     }
 
-    function nodeLoadModuleByRelativeName(candidate: string, supportedExtensions: string[], failedLookupLocations: string[],
-        onlyRecordFailures: boolean, state: ModuleResolutionState): string {
+    /*
+     * 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;
 
-        if (state.traceEnabled) {
-            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
+    /**
+     * 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);
         }
-
-        const resolvedFileName = loadModuleFromFile(candidate, supportedExtensions, failedLookupLocations, onlyRecordFailures, state);
-
-        return resolvedFileName || loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, onlyRecordFailures, state);
     }
 
-
     function tryLoadModuleUsingRootDirs(moduleName: string, containingDirectory: string, loader: ResolutionKindSpecificLoader,
         failedLookupLocations: string[], supportedExtensions: string[], state: ModuleResolutionState): string {
 
@@ -392,129 +512,6 @@ namespace ts {
         }
     }
 
-    /**
-     * 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);
-        }
-    }
-
-
-    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;
-
     /**
      * patternStrings contains both pattern strings (containing "*") and regular strings.
      * Return an exact match if possible, or a pattern match, or undefined.
@@ -569,8 +566,8 @@ namespace ts {
 
     function isPatternMatch({prefix, suffix}: Pattern, candidate: string) {
         return candidate.length >= prefix.length + suffix.length &&
-               startsWith(candidate, prefix) &&
-               endsWith(candidate, suffix);
+            startsWith(candidate, prefix) &&
+            endsWith(candidate, suffix);
     }
 
     /* @internal */
@@ -584,14 +581,233 @@ namespace ts {
         };
     }
 
+    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);
     }
 
-    /* @internal */
-    export function pathToPackageJson(directory: string): string {
+    /**
+     * @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 {
+        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 || 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);
+        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 };
+    }
 }

src/compiler/program.ts

@@ -75,153 +75,6 @@ namespace ts {
         return getNormalizedPathFromPathComponents(commonPathComponents);
     }
 
-    const typeReferenceExtensions = [".d.ts"];
-
-    // @internal
-    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 && 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; getCurrentDirectory?(): string; }): string[] | undefined {
-        if (!host.directoryExists) {
-            return [combinePaths(currentDirectory, nodeModulesAtTypes)];
-        }
-
-        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
-        };
-    }
-
     interface OutputFingerprint {
         hash: string;
         byteOrderMark: boolean;
@@ -353,6 +206,7 @@ namespace ts {
             readFile: fileName => sys.readFile(fileName),
             trace: (s: string) => sys.write(s + newLine),
             directoryExists: directoryName => sys.directoryExists(directoryName),
+            getEnvironmentVariable: name => getEnvironmentVariable(name, /*host*/ undefined),
             getDirectories: (path: string) => sys.getDirectories(path),
             realpath
         };
@@ -435,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[] = [];
@@ -1102,7 +918,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) {
@@ -1186,6 +1002,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) {
@@ -1219,7 +1046,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:
@@ -1702,7 +1529,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;
@@ -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,211 @@
 /* @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;
+
+        /**
+         * Gets test data for source maps.
+         */
+        getSourceMapData(): SourceMapData;
+
+        /**
+         * 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 mapping for the start of a range.
+         *
+         * If the range's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param range The range to emit.
+         */
+        emitStart(range: TextRange): void;
+
+        /**
+         * Emits a mapping for the start of a range.
+         *
+         * If the node's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param range The range to emit.
+         * @param contextNode The node for the current range.
+         * @param ignoreNodeCallback A callback used to determine whether to skip source map
+         *        emit for the start position of this node.
+         * @param ignoreChildrenCallback A callback used to determine whether to skip source
+         *        map emit for all children of this node.
+         * @param getTextRangeCallbackCallback A callback used to get a custom source map
+         *        range for this node.
+         */
+        emitStart(range: TextRange, contextNode: Node, ignoreNodeCallback: (node: Node) => boolean, ignoreChildrenCallback: (node: Node) => boolean, getTextRangeCallbackCallback: (node: Node) => TextRange): void;
+
+        /**
+         * Emits a mapping for the end of a range.
+         *
+         * If the range's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param range The range to emit.
+         */
+        emitEnd(range: TextRange): void;
+
+        /**
+         * Emits a mapping for the end of a range.
+         *
+         * If the node's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param range The range to emit.
+         * @param contextNode The node for the current range.
+         * @param ignoreNodeCallback A callback used to determine whether to skip source map
+         *        emit for the end position of this node.
+         * @param ignoreChildrenCallback A callback used to determine whether to skip source
+         *        map emit for all children of this node.
+         * @param getTextRangeCallbackCallback A callback used to get a custom source map
+         *        range for this node.
+         */
+        emitEnd(range: TextRange, contextNode: Node, ignoreNodeCallback: (node: Node) => boolean, ignoreChildrenCallback: (node: Node) => boolean, getTextRangeCallbackCallback: (node: Node) => TextRange): void;
+
+        /**
+         * Emits a mapping for the start position of a token.
+         *
+         * If the token's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param token The token to emit.
+         * @param tokenStartPos The start position of the token.
+         * @returns The start position of the token, following any trivia.
+         */
+        emitTokenStart(token: SyntaxKind, tokenStartPos: number): number;
+
+        /**
+         * Emits a mapping for the start position of a token.
+         *
+         * If the token's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param token The token to emit.
+         * @param tokenStartPos The start position of the token.
+         * @param contextNode The node containing this token.
+         * @param ignoreTokenCallback A callback used to determine whether to skip source map
+         *        emit for the start position of this token.
+         * @param getTokenTextRangeCallback A callback used to get a custom source
+         *        map range for this node.
+         * @returns The start position of the token, following any trivia.
+         */
+        emitTokenStart(token: SyntaxKind, tokenStartPos: number, contextNode: Node, ignoreTokenCallback: (node: Node, token: SyntaxKind) => boolean, getTokenTextRangeCallback: (node: Node, token: SyntaxKind) => TextRange): number;
+
+        /**
+         * Emits a mapping for the end position of a token.
+         *
+         * If the token's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param token The token to emit.
+         * @param tokenEndPos The end position of the token.
+         * @returns The end position of the token.
+         */
+        emitTokenEnd(token: SyntaxKind, tokenEndPos: number): number;
+
+        /**
+         * Emits a mapping for the end position of a token.
+         *
+         * If the token's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param token The token to emit.
+         * @param tokenEndPos The end position of the token.
+         * @param contextNode The node containing this token.
+         * @param ignoreTokenCallback A callback used to determine whether to skip source map
+         *        emit for the end position of this token.
+         * @param getTokenTextRangeCallback A callback used to get a custom source
+         *        map range for this node.
+         * @returns The end position of the token.
+         */
+        emitTokenEnd(token: SyntaxKind, tokenEndPos: number, contextNode: Node, ignoreTokenCallback: (node: Node, token: SyntaxKind) => boolean, getTokenTextRangeCallback: (node: Node, token: SyntaxKind) => TextRange): number;
+
+        /*@deprecated*/ changeEmitSourcePos(): void;
+        /*@deprecated*/ stopOverridingSpan(): void;
+
+        /**
+         * Gets the text for the source map.
+         */
+        getText(): string;
+
+        /**
+         * Gets the SourceMappingURL for the source map.
+         */
+        getSourceMappingURL(): string;
+    }
+
+    export function createSourceMapWriter(host: EmitHost, writer: EmitTextWriter): SourceMapWriter {
+        const compilerOptions = host.getCompilerOptions();
+        if (compilerOptions.sourceMap || compilerOptions.inlineSourceMap) {
+            if (compilerOptions.extendedDiagnostics) {
+                return createSourceMapWriterWithExtendedDiagnostics(host, writer);
+            }
+
+            return createSourceMapWriterWorker(host, writer);
+        }
+        else {
+            return getNullSourceMapWriter();
+        }
     }
 
     let nullSourceMapWriter: SourceMapWriter;
+
+    export function getNullSourceMapWriter(): SourceMapWriter {
+        if (nullSourceMapWriter === undefined) {
+            nullSourceMapWriter = {
+                initialize(filePath: string, sourceMapFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean): void { },
+                reset(): void { },
+                getSourceMapData(): SourceMapData { return undefined; },
+                setSourceFile(sourceFile: SourceFile): void { },
+                emitPos(pos: number): void { },
+                emitStart(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void { },
+                emitEnd(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void { },
+                emitTokenStart(token: SyntaxKind, pos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number { return -1; },
+                emitTokenEnd(token: SyntaxKind, end: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number { return -1; },
+                changeEmitSourcePos(): void { },
+                stopOverridingSpan(): void { },
+                getText(): string { return undefined; },
+                getSourceMappingURL(): string { return undefined; }
+            };
+        }
+
+        return nullSourceMapWriter;
+    }
+
     // Used for initialize lastEncodedSourceMapSpan and reset lastEncodedSourceMapSpan when updateLastEncodedAndRecordedSpans
     const defaultLastEncodedSourceMapSpan: SourceMapSpan = {
         emittedLine: 1,
@@ -25,29 +217,11 @@ 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 {
+    function createSourceMapWriterWorker(host: EmitHost, writer: EmitTextWriter): SourceMapWriter {
         const compilerOptions = host.getCompilerOptions();
         const extendedDiagnostics = compilerOptions.extendedDiagnostics;
         let currentSourceFile: SourceFile;
+        let currentSourceText: string;
         let sourceMapDir: string; // The directory in which sourcemap will be
         let stopOverridingSpan = false;
         let modifyLastSourcePos = false;
@@ -63,25 +237,45 @@ namespace ts {
         // Source map data
         let sourceMapData: SourceMapData;
 
+        // This keeps track of the number of times `disable` has been called without a
+        // corresponding call to `enable`. As long as this value is non-zero, mappings will not
+        // be recorded.
+        // This is primarily used to provide a better experience when debugging binding
+        // patterns and destructuring assignments for simple expressions.
+        let disableDepth: number;
+
         return {
+            initialize,
+            reset,
             getSourceMapData: () => sourceMapData,
             setSourceFile,
             emitPos,
             emitStart,
             emitEnd,
+            emitTokenStart,
+            emitTokenEnd,
             changeEmitSourcePos,
+            stopOverridingSpan: () => stopOverridingSpan = true,
             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 (sourceMapData) {
                 reset();
             }
 
             currentSourceFile = undefined;
+            currentSourceText = undefined;
+            disableDepth = 0;
 
             // Current source map file and its index in the sources list
             sourceMapSourceIndex = -1;
@@ -140,6 +334,9 @@ namespace ts {
             }
         }
 
+        /**
+         * Reset the SourceMapWriter to an empty state.
+         */
         function reset() {
             currentSourceFile = undefined;
             sourceMapDir = undefined;
@@ -148,6 +345,23 @@ namespace ts {
             lastEncodedSourceMapSpan = undefined;
             lastEncodedNameIndex = undefined;
             sourceMapData = undefined;
+            disableDepth = 0;
+        }
+
+        /**
+         * Re-enables the recording of mappings.
+         */
+        function enable() {
+            if (disableDepth > 0) {
+                disableDepth--;
+            }
+        }
+
+        /**
+         * Disables the recording of mappings.
+         */
+        function disable() {
+            disableDepth++;
         }
 
         function updateLastEncodedAndRecordedSpans() {
@@ -236,8 +450,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 (positionIsSynthesized(pos) || disableDepth > 0) {
                 return;
             }
 
@@ -291,27 +513,201 @@ namespace ts {
             }
         }
 
-        function getStartPos(range: TextRange) {
+        function getStartPosPastDecorators(range: TextRange) {
             const rangeHasDecorators = !!(range as Node).decorators;
-            return range.pos !== -1 ? skipTrivia(currentSourceFile.text, rangeHasDecorators ? (range as Node).decorators.end : range.pos) : -1;
+            return skipTrivia(currentSourceText, rangeHasDecorators ? (range as Node).decorators.end : range.pos);
         }
 
-        function emitStart(range: TextRange) {
-            emitPos(getStartPos(range));
+        /**
+         * Emits a mapping for the start of a range.
+         *
+         * If the range's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param range The range to emit.0
+         */
+        function emitStart(range: TextRange): void;
+        /**
+         * Emits a mapping for the start of a range.
+         *
+         * If the node's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param range The range to emit.
+         * @param contextNode The node for the current range.
+         * @param ignoreNodeCallback A callback used to determine whether to skip source map
+         *        emit for the start position of this node.
+         * @param ignoreChildrenCallback A callback used to determine whether to skip source
+         *        map emit for all children of this node.
+         * @param getTextRangeCallbackCallback A callback used to get a custom source map
+         *        range for this node.
+         */
+        function emitStart(range: TextRange, contextNode: Node, ignoreNodeCallback: (node: Node) => boolean, ignoreChildrenCallback: (node: Node) => boolean, getTextRangeCallback: (node: Node) => TextRange): void;
+        function emitStart(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange) {
+            if (contextNode) {
+                if (!ignoreNodeCallback(contextNode)) {
+                    range = getTextRangeCallback(contextNode) || range;
+                    emitPos(getStartPosPastDecorators(range));
+                }
+
+                if (ignoreChildrenCallback(contextNode)) {
+                    disable();
+                }
+            }
+            else {
+                emitPos(getStartPosPastDecorators(range));
+            }
         }
 
-        function emitEnd(range: TextRange, stopOverridingEnd?: boolean) {
-            emitPos(range.end);
-            stopOverridingSpan = stopOverridingEnd;
+        /**
+         * Emits a mapping for the end of a range.
+         *
+         * If the range's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param range The range to emit.
+         */
+        function emitEnd(range: TextRange): void;
+        /**
+         * Emits a mapping for the end of a range.
+         *
+         * If the node's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param range The range to emit.
+         * @param contextNode The node for the current range.
+         * @param ignoreNodeCallback A callback used to determine whether to skip source map
+         *        emit for the end position of this node.
+         * @param ignoreChildrenCallback A callback used to determine whether to skip source
+         *        map emit for all children of this node.
+         * @param getTextRangeCallbackCallback A callback used to get a custom source map
+         *        range for this node.
+         */
+        function emitEnd(range: TextRange, contextNode: Node, ignoreNodeCallback: (node: Node) => boolean, ignoreChildrenCallback: (node: Node) => boolean, getTextRangeCallback: (node: Node) => TextRange): void;
+        function emitEnd(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange) {
+            if (contextNode) {
+                if (ignoreChildrenCallback(contextNode)) {
+                    enable();
+                }
+
+                if (!ignoreNodeCallback(contextNode)) {
+                    range = getTextRangeCallback(contextNode) || range;
+                    emitPos(range.end);
+                }
+            }
+            else {
+                emitPos(range.end);
+            }
+
+            stopOverridingSpan = false;
         }
 
+        /**
+         * Emits a mapping for the start position of a token.
+         *
+         * If the token's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param token The token to emit.
+         * @param tokenStartPos The start position of the token.
+         * @returns The start position of the token, following any trivia.
+         */
+        function emitTokenStart(token: SyntaxKind, tokenStartPos: number): number;
+        /**
+         * Emits a mapping for the start position of a token.
+         *
+         * If the token's start position is synthetic (undefined or a negative value), no mapping
+         * will be created. Any trivia at the start position in the original source will be
+         * skipped.
+         *
+         * @param token The token to emit.
+         * @param tokenStartPos The start position of the token.
+         * @param contextNode The node containing this token.
+         * @param ignoreTokenCallback A callback used to determine whether to skip source map
+         *        emit for the start position of this token.
+         * @param getTokenTextRangeCallback A callback used to get a custom source
+         *        map range for this node.
+         * @returns The start position of the token, following any trivia.
+         */
+        function emitTokenStart(token: SyntaxKind, tokenStartPos: number, contextNode: Node, ignoreTokenCallback: (node: Node, token: SyntaxKind) => boolean, getTokenTextRangeCallback: (node: Node, token: SyntaxKind) => TextRange): number;
+        function emitTokenStart(token: SyntaxKind, tokenStartPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node, token: SyntaxKind) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
+            if (contextNode) {
+                if (ignoreTokenCallback(contextNode, token)) {
+                    return skipTrivia(currentSourceText, tokenStartPos);
+                }
+
+                const range = getTokenTextRangeCallback(contextNode, token);
+                if (range) {
+                    tokenStartPos = range.pos;
+                }
+            }
+
+            tokenStartPos = skipTrivia(currentSourceText, tokenStartPos);
+            emitPos(tokenStartPos);
+            return tokenStartPos;
+        }
+
+        /**
+         * Emits a mapping for the end position of a token.
+         *
+         * If the token's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param token The token to emit.
+         * @param tokenEndPos The end position of the token.
+         * @returns The end position of the token.
+         */
+        function emitTokenEnd(token: SyntaxKind, tokenEndPos: number): number;
+        /**
+         * Emits a mapping for the end position of a token.
+         *
+         * If the token's end position is synthetic (undefined or a negative value), no mapping
+         * will be created.
+         *
+         * @param token The token to emit.
+         * @param tokenEndPos The end position of the token.
+         * @param contextNode The node containing this token.
+         * @param ignoreTokenCallback A callback used to determine whether to skip source map
+         *        emit for the end position of this token.
+         * @param getTokenTextRangeCallback A callback used to get a custom source
+         *        map range for this node.
+         * @returns The end position of the token.
+         */
+        function emitTokenEnd(token: SyntaxKind, tokenEndPos: number, contextNode: Node, ignoreTokenCallback: (node: Node, token: SyntaxKind) => boolean, getTokenTextRangeCallback: (node: Node, token: SyntaxKind) => TextRange): number;
+        function emitTokenEnd(token: SyntaxKind, tokenEndPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node, token: SyntaxKind) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
+            if (contextNode) {
+                if (ignoreTokenCallback(contextNode, token)) {
+                    return tokenEndPos;
+                }
+
+                const range = getTokenTextRangeCallback(contextNode, token);
+                if (range) {
+                    tokenEndPos = range.end;
+                }
+            }
+
+            emitPos(tokenEndPos);
+            return tokenEndPos;
+        }
+
+
+        // @deprecated
         function changeEmitSourcePos() {
             Debug.assert(!modifyLastSourcePos);
             modifyLastSourcePos = true;
         }
 
+        /**
+         * Set the current source file.
+         *
+         * @param sourceFile The source file.
+         */
         function setSourceFile(sourceFile: SourceFile) {
             currentSourceFile = sourceFile;
+            currentSourceText = currentSourceFile.text;
 
             // Add the file to tsFilePaths
             // If sourceroot option: Use the relative path corresponding to the common directory path
@@ -330,14 +726,17 @@ 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() {
             encodeLastRecordedSourceMapSpan();
 
@@ -352,6 +751,9 @@ namespace ts {
             });
         }
 
+        /**
+         * Gets the SourceMappingURL for the source map.
+         */
         function getSourceMappingURL() {
             if (compilerOptions.inlineSourceMap) {
                 // Encode the sourceMap into the sourceMap url
@@ -364,6 +766,61 @@ namespace ts {
         }
     }
 
+    function createSourceMapWriterWithExtendedDiagnostics(host: EmitHost, writer: EmitTextWriter): SourceMapWriter {
+        const {
+            initialize,
+            reset,
+            getSourceMapData,
+            setSourceFile,
+            emitPos,
+            emitStart,
+            emitEnd,
+            emitTokenStart,
+            emitTokenEnd,
+            changeEmitSourcePos,
+            stopOverridingSpan,
+            getText,
+            getSourceMappingURL,
+        } = createSourceMapWriterWorker(host, writer);
+        return {
+            initialize,
+            reset,
+            getSourceMapData,
+            setSourceFile,
+            emitPos(pos: number): void {
+                 performance.mark("sourcemapStart");
+                emitPos(pos);
+                performance.measure("sourceMapTime", "sourcemapStart");
+            },
+            emitStart(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void {
+                performance.mark("emitSourcemap:emitStart");
+                emitStart(range, contextNode, ignoreNodeCallback, ignoreChildrenCallback, getTextRangeCallback);
+                performance.measure("sourceMapTime", "emitSourcemap:emitStart");
+            },
+            emitEnd(range: TextRange, contextNode?: Node, ignoreNodeCallback?: (node: Node) => boolean, ignoreChildrenCallback?: (node: Node) => boolean, getTextRangeCallback?: (node: Node) => TextRange): void {
+                performance.mark("emitSourcemap:emitEnd");
+                emitEnd(range, contextNode, ignoreNodeCallback, ignoreChildrenCallback, getTextRangeCallback);
+                performance.measure("sourceMapTime", "emitSourcemap:emitEnd");
+            },
+            emitTokenStart(token: SyntaxKind, tokenStartPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
+                performance.mark("emitSourcemap:emitTokenStart");
+                tokenStartPos = emitTokenStart(token, tokenStartPos, contextNode, ignoreTokenCallback, getTokenTextRangeCallback);
+                performance.measure("sourceMapTime", "emitSourcemap:emitTokenStart");
+                return tokenStartPos;
+            },
+            emitTokenEnd(token: SyntaxKind, tokenEndPos: number, contextNode?: Node, ignoreTokenCallback?: (node: Node) => boolean, getTokenTextRangeCallback?: (node: Node, token: SyntaxKind) => TextRange): number {
+                performance.mark("emitSourcemap:emitTokenEnd");
+                tokenEndPos = emitTokenEnd(token, tokenEndPos, contextNode, ignoreTokenCallback, getTokenTextRangeCallback);
+                performance.measure("sourceMapTime", "emitSourcemap:emitTokenEnd");
+                return tokenEndPos;
+            },
+            changeEmitSourcePos,
+            stopOverridingSpan,
+            getText,
+            getSourceMappingURL,
+        };
+    }
+
     const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
     function base64FormatEncode(inValue: number) {

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,6 +80,7 @@ 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() {
@@ -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) {
@@ -432,7 +429,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 = {
@@ -508,6 +505,9 @@ namespace ts {
                     return process.cwd();
                 },
                 getDirectories,
+                getEnvironmentVariable(name: string) {
+                    return process.env[name] || "";
+                },
                 readDirectory,
                 getModifiedTime(path) {
                     try {
@@ -543,6 +543,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 +582,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);

src/compiler/transformer.ts

@@ -0,0 +1,632 @@
+/// <reference path="visitor.ts" />
+/// <reference path="transformers/ts.ts" />
+/// <reference path="transformers/jsx.ts" />
+/// <reference path="transformers/es7.ts" />
+/// <reference path="transformers/es6.ts" />
+/// <reference path="transformers/generators.ts" />
+/// <reference path="transformers/module/module.ts" />
+/// <reference path="transformers/module/system.ts" />
+/// <reference path="transformers/module/es6.ts" />
+
+/* @internal */
+namespace ts {
+    const moduleTransformerMap = createMap<Transformer>({
+        [ModuleKind.ES6]: transformES6Module,
+        [ModuleKind.System]: transformSystemModule,
+        [ModuleKind.AMD]: transformModule,
+        [ModuleKind.CommonJS]: transformModule,
+        [ModuleKind.UMD]: transformModule,
+        [ModuleKind.None]: transformModule,
+    });
+
+    const enum SyntaxKindFeatureFlags {
+        Substitution = 1 << 0,
+        EmitNotifications = 1 << 1,
+    }
+
+    export interface TransformationResult {
+        /**
+         * Gets the transformed source files.
+         */
+        getSourceFiles(): SourceFile[];
+
+        /**
+         * Gets the TextRange to use for source maps for a token of a node.
+         */
+        getTokenSourceMapRange(node: Node, token: SyntaxKind): TextRange;
+
+        /**
+         * Determines whether expression substitutions are enabled for the provided node.
+         */
+        isSubstitutionEnabled(node: Node): boolean;
+
+        /**
+         * Determines whether before/after emit notifications should be raised in the pretty
+         * printer when it emits a node.
+         */
+        isEmitNotificationEnabled(node: Node): boolean;
+
+        /**
+         * Hook used by transformers to substitute expressions just before they
+         * are emitted by the pretty printer.
+         *
+         * @param node The node to substitute.
+         * @param isExpression A value indicating whether the node is in an expression context.
+         */
+        onSubstituteNode(node: Node, isExpression: boolean): Node;
+
+        /**
+         * Hook used to allow transformers to capture state before or after
+         * the printer emits a node.
+         *
+         * @param node The node to emit.
+         * @param emitCallback A callback used to emit the node.
+         */
+        onEmitNode(node: Node, emitCallback: (node: Node) => void): void;
+
+        /**
+         * Reset transient transformation properties on parse tree nodes.
+         */
+        dispose(): void;
+    }
+
+    export interface TransformationContext extends LexicalEnvironment {
+        getCompilerOptions(): CompilerOptions;
+        getEmitResolver(): EmitResolver;
+        getEmitHost(): EmitHost;
+
+        /**
+         * Gets flags used to customize later transformations or emit.
+         */
+        getNodeEmitFlags(node: Node): NodeEmitFlags;
+
+        /**
+         * Sets flags used to customize later transformations or emit.
+         */
+        setNodeEmitFlags<T extends Node>(node: T, flags: NodeEmitFlags): T;
+
+        /**
+         * Gets the TextRange to use for source maps for the node.
+         */
+        getSourceMapRange(node: Node): TextRange;
+
+        /**
+         * Sets the TextRange to use for source maps for the node.
+         */
+        setSourceMapRange<T extends Node>(node: T, range: TextRange): T;
+
+        /**
+         * Gets the TextRange to use for source maps for a token of a node.
+         */
+        getTokenSourceMapRange(node: Node, token: SyntaxKind): TextRange;
+
+        /**
+         * Sets the TextRange to use for source maps for a token of a node.
+         */
+        setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: TextRange): T;
+
+        /**
+         * Gets the TextRange to use for comments for the node.
+         */
+        getCommentRange(node: Node): TextRange;
+
+        /**
+         * Sets the TextRange to use for comments for the node.
+         */
+        setCommentRange<T extends Node>(node: T, range: TextRange): T;
+
+        /**
+         * 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?: (node: Node, isExpression: boolean) => 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?: (node: Node, emit: (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);
+        }
+
+        transformers.push(transformES7);
+
+        if (languageVersion < ScriptTarget.ES6) {
+            transformers.push(transformES6);
+            transformers.push(transformGenerators);
+        }
+
+        return transformers;
+    }
+
+    /**
+     * Tracks a monotonically increasing transformation id used to associate a node with a specific
+     * transformation. This ensures transient properties related to transformations can be safely
+     * stored on source tree nodes that may be reused across multiple transformations (such as
+     * with compile-on-save).
+     */
+    let nextTransformId = 1;
+
+    /**
+     * 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 transformId = nextTransformId;
+        nextTransformId++;
+
+        const tokenSourceMapRanges = createMap<TextRange>();
+        const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
+        const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
+        const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
+        const parseTreeNodesWithAnnotations: Node[] = [];
+
+        let lastTokenSourceMapRangeNode: Node;
+        let lastTokenSourceMapRangeToken: SyntaxKind;
+        let lastTokenSourceMapRange: TextRange;
+        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,
+            getNodeEmitFlags,
+            setNodeEmitFlags,
+            getSourceMapRange,
+            setSourceMapRange,
+            getTokenSourceMapRange,
+            setTokenSourceMapRange,
+            getCommentRange,
+            setCommentRange,
+            hoistVariableDeclaration,
+            hoistFunctionDeclaration,
+            startLexicalEnvironment,
+            endLexicalEnvironment,
+            onSubstituteNode,
+            enableSubstitution,
+            isSubstitutionEnabled,
+            onEmitNode,
+            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 {
+            getSourceFiles: () => transformed,
+            getTokenSourceMapRange,
+            isSubstitutionEnabled,
+            isEmitNotificationEnabled,
+            onSubstituteNode: context.onSubstituteNode,
+            onEmitNode: context.onEmitNode,
+            dispose() {
+                // During transformation we may need to annotate a parse tree node with transient
+                // transformation properties. As parse tree nodes live longer than transformation
+                // nodes, we need to make sure we reclaim any memory allocated for custom ranges
+                // from these nodes to ensure we do not hold onto entire subtrees just for position
+                // information. We also need to reset these nodes to a pre-transformation state
+                // for incremental parsing scenarios so that we do not impact later emit.
+                for (const node of parseTreeNodesWithAnnotations) {
+                    if (node.transformId === transformId) {
+                        node.transformId = 0;
+                        node.emitFlags = 0;
+                        node.commentRange = undefined;
+                        node.sourceMapRange = undefined;
+                    }
+                }
+
+                parseTreeNodesWithAnnotations.length = 0;
+            }
+        };
+
+        /**
+         * 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;
+        }
+
+        /**
+         * Default hook for 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(node: Node, isExpression: boolean) {
+            return 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
+                || (getNodeEmitFlags(node) & NodeEmitFlags.AdviseOnEmitNode) !== 0;
+        }
+
+        /**
+         * Default hook for node emit.
+         *
+         * @param node The node to emit.
+         * @param emit A callback used to emit the node in the printer.
+         */
+        function onEmitNode(node: Node, emit: (node: Node) => void) {
+            emit(node);
+        }
+
+        /**
+         * Associates a node with the current transformation, initializing
+         * various transient transformation properties.
+         *
+         * @param node The node.
+         */
+        function beforeSetAnnotation(node: Node) {
+            if ((node.flags & NodeFlags.Synthesized) === 0 && node.transformId !== transformId) {
+                // To avoid holding onto transformation artifacts, we keep track of any
+                // parse tree node we are annotating. This allows us to clean them up after
+                // all transformations have completed.
+                parseTreeNodesWithAnnotations.push(node);
+                node.transformId = transformId;
+            }
+        }
+
+        /**
+         * Gets flags that control emit behavior of a node.
+         *
+         * If the node does not have its own NodeEmitFlags set, the node emit flags of its
+         * original pointer are used.
+         *
+         * @param node The node.
+         */
+        function getNodeEmitFlags(node: Node) {
+            return node.emitFlags;
+        }
+
+        /**
+         * Sets flags that control emit behavior of a node.
+         *
+         * @param node The node.
+         * @param emitFlags The NodeEmitFlags for the node.
+         */
+        function setNodeEmitFlags<T extends Node>(node: T, emitFlags: NodeEmitFlags) {
+            beforeSetAnnotation(node);
+            node.emitFlags = emitFlags;
+            return node;
+        }
+
+        /**
+         * Gets a custom text range to use when emitting source maps.
+         *
+         * If a node does not have its own custom source map text range, the custom source map
+         * text range of its original pointer is used.
+         *
+         * @param node The node.
+         */
+        function getSourceMapRange(node: Node) {
+            return node.sourceMapRange || node;
+        }
+
+        /**
+         * Sets a custom text range to use when emitting source maps.
+         *
+         * @param node The node.
+         * @param range The text range.
+         */
+        function setSourceMapRange<T extends Node>(node: T, range: TextRange) {
+            beforeSetAnnotation(node);
+            node.sourceMapRange = range;
+            return node;
+        }
+
+        /**
+         * Gets the TextRange to use for source maps for a token of a node.
+         *
+         * If a node does not have its own custom source map text range for a token, the custom
+         * source map text range for the token of its original pointer is used.
+         *
+         * @param node The node.
+         * @param token The token.
+         */
+        function getTokenSourceMapRange(node: Node, token: SyntaxKind) {
+            // As a performance optimization, use the cached value of the most recent node.
+            // This helps for cases where this function is called repeatedly for the same node.
+            if (lastTokenSourceMapRangeNode === node && lastTokenSourceMapRangeToken === token) {
+                return lastTokenSourceMapRange;
+            }
+
+            // Get the custom token source map range for a node or from one of its original nodes.
+            // Custom token ranges are not stored on the node to avoid the GC burden.
+            let range: TextRange;
+            let current = node;
+            while (current) {
+                range = current.id ? tokenSourceMapRanges[current.id + "-" + token] : undefined;
+                if (range !== undefined) {
+                    break;
+                }
+
+                current = current.original;
+            }
+
+            // Cache the most recently requested value.
+            lastTokenSourceMapRangeNode = node;
+            lastTokenSourceMapRangeToken = token;
+            lastTokenSourceMapRange = range;
+            return range;
+        }
+
+        /**
+         * Sets the TextRange to use for source maps for a token of a node.
+         *
+         * @param node The node.
+         * @param token The token.
+         * @param range The text range.
+         */
+        function setTokenSourceMapRange<T extends Node>(node: T, token: SyntaxKind, range: TextRange) {
+            // Cache the most recently requested value.
+            lastTokenSourceMapRangeNode = node;
+            lastTokenSourceMapRangeToken = token;
+            lastTokenSourceMapRange = range;
+            tokenSourceMapRanges[getNodeId(node) + "-" + token] = range;
+            return node;
+        }
+
+        /**
+         * Gets a custom text range to use when emitting comments.
+         *
+         * If a node does not have its own custom source map text range, the custom source map
+         * text range of its original pointer is used.
+         *
+         * @param node The node.
+         */
+        function getCommentRange(node: Node) {
+            return node.commentRange || node;
+        }
+
+        /**
+         * Sets a custom text range to use when emitting comments.
+         */
+        function setCommentRange<T extends Node>(node: T, range: TextRange) {
+            beforeSetAnnotation(node);
+            node.commentRange = range;
+            return 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;
+        }
+    }
+
+    /**
+     * 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.
+     */
+    function chain<T, U>(...args: ((t: T) => (u: U) => U)[]): (t: T) => (u: U) => U;
+    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.
+     */
+    function compose<T>(...args: ((t: T) => T)[]): (t: T) => T;
+    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;
+        }
+    }
+}

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.
+            context.setNodeEmitFlags(expression, NodeEmitFlags.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.
+            context.setNodeEmitFlags(declaration, NodeEmitFlags.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.
+            context.setNodeEmitFlags(declaration, NodeEmitFlags.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.
+            context.setNodeEmitFlags(expression, NodeEmitFlags.NoNestedSourceMaps);
+
+            pendingAssignments.push(expression);
+            return expression;
+        }
+    }
+
+    function flattenDestructuring(
+        context: TransformationContext,
+        root: 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);
+                context.setSourceMapRange(name, target);
+                context.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: 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/es7.ts

@@ -0,0 +1,97 @@
+/// <reference path="../factory.ts" />
+/// <reference path="../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    export function transformES7(context: TransformationContext) {
+        const { hoistVariableDeclaration } = context;
+
+        return transformSourceFile;
+
+        function transformSourceFile(node: SourceFile) {
+            return visitEachChild(node, visitor, context);
+        }
+
+        function visitor(node: Node): VisitResult<Node> {
+            if (node.transformFlags & TransformFlags.ES7) {
+                return visitorWorker(node);
+            }
+            else if (node.transformFlags & TransformFlags.ContainsES7) {
+                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 ES7 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/jsx.ts

@@ -0,0 +1,531 @@
+/// <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) {
+            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/es6.ts

@@ -0,0 +1,140 @@
+/// <reference path="../../factory.ts" />
+/// <reference path="../../visitor.ts" />
+
+/*@internal*/
+namespace ts {
+    export function transformES6Module(context: TransformationContext) {
+        const compilerOptions = context.getCompilerOptions();
+        const resolver = context.getEmitResolver();
+
+        let currentSourceFile: SourceFile;
+
+        return transformSourceFile;
+
+        function transformSourceFile(node: SourceFile) {
+            if (isExternalModule(node) || compilerOptions.isolatedModules) {
+                currentSourceFile = node;
+                return visitEachChild(node, visitor, context);
+            }
+            return node;
+        }
+
+        function visitor(node: Node): VisitResult<Node> {
+            switch (node.kind) {
+                case SyntaxKind.ImportDeclaration:
+                    return visitImportDeclaration(<ImportDeclaration>node);
+                case SyntaxKind.ImportEqualsDeclaration:
+                    return visitImportEqualsDeclaration(<ImportEqualsDeclaration>node);
+                case SyntaxKind.ImportClause:
+                    return visitImportClause(<ImportClause>node);
+                case SyntaxKind.NamedImports:
+                case SyntaxKind.NamespaceImport:
+                    return visitNamedBindings(<NamedImportBindings>node);
+                case SyntaxKind.ImportSpecifier:
+                    return visitImportSpecifier(<ImportSpecifier>node);
+                case SyntaxKind.ExportAssignment:
+                    return visitExportAssignment(<ExportAssignment>node);
+                case SyntaxKind.ExportDeclaration:
+                    return visitExportDeclaration(<ExportDeclaration>node);
+                case SyntaxKind.NamedExports:
+                    return visitNamedExports(<NamedExports>node);
+                case SyntaxKind.ExportSpecifier:
+                    return visitExportSpecifier(<ExportSpecifier>node);
+            }
+
+            return node;
+        }
+
+        function visitExportAssignment(node: ExportAssignment): ExportAssignment {
+            if (node.isExportEquals) {
+                return undefined; // do not emit export equals for ES6
+            }
+            const original = getOriginalNode(node);
+            return nodeIsSynthesized(original) || resolver.isValueAliasDeclaration(original) ? node : undefined;
+        }
+
+        function visitExportDeclaration(node: ExportDeclaration): ExportDeclaration {
+            if (!node.exportClause) {
+                return resolver.moduleExportsSomeValue(node.moduleSpecifier) ? node : undefined;
+            }
+            if (!resolver.isValueAliasDeclaration(node)) {
+                return undefined;
+            }
+            const newExportClause = visitNode(node.exportClause, visitor, isNamedExports, /*optional*/ true);
+            if (node.exportClause === newExportClause) {
+                return node;
+            }
+            return newExportClause
+                ? createExportDeclaration(
+                    /*decorators*/ undefined,
+                    /*modifiers*/ undefined,
+                    newExportClause,
+                    node.moduleSpecifier)
+                : undefined;
+        }
+
+        function visitNamedExports(node: NamedExports): NamedExports {
+            const newExports = visitNodes(node.elements, visitor, isExportSpecifier);
+            if (node.elements === newExports) {
+                return node;
+            }
+            return newExports.length ? createNamedExports(newExports) : undefined;
+        }
+
+        function visitExportSpecifier(node: ExportSpecifier): ExportSpecifier {
+            return resolver.isValueAliasDeclaration(node) ? node : undefined;
+        }
+
+        function visitImportEqualsDeclaration(node: ImportEqualsDeclaration): ImportEqualsDeclaration {
+            return !isExternalModuleImportEqualsDeclaration(node) || resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+        }
+
+        function visitImportDeclaration(node: ImportDeclaration) {
+            if (node.importClause) {
+                const newImportClause = visitNode(node.importClause, visitor, isImportClause);
+                if (!newImportClause.name && !newImportClause.namedBindings) {
+                    return undefined;
+                }
+                else if (newImportClause !== node.importClause) {
+                    return createImportDeclaration(
+                        /*decorators*/ undefined,
+                        /*modifiers*/ undefined,
+                        newImportClause,
+                        node.moduleSpecifier);
+                }
+            }
+            return node;
+        }
+
+        function visitImportClause(node: ImportClause): ImportClause {
+            let newDefaultImport = node.name;
+            if (!resolver.isReferencedAliasDeclaration(node)) {
+                newDefaultImport = undefined;
+            }
+            const newNamedBindings = visitNode(node.namedBindings, visitor, isNamedImportBindings, /*optional*/ true);
+            return newDefaultImport !== node.name || newNamedBindings !== node.namedBindings
+                ? createImportClause(newDefaultImport, newNamedBindings)
+                : node;
+        }
+
+        function visitNamedBindings(node: NamedImportBindings): VisitResult<NamedImportBindings> {
+            if (node.kind === SyntaxKind.NamespaceImport) {
+                return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+            }
+            else {
+                const newNamedImportElements = visitNodes((<NamedImports>node).elements, visitor, isImportSpecifier);
+                if (!newNamedImportElements || newNamedImportElements.length == 0) {
+                    return undefined;
+                }
+                if (newNamedImportElements === (<NamedImports>node).elements) {
+                    return node;
+                }
+                return createNamedImports(newNamedImportElements);
+            }
+        }
+
+        function visitImportSpecifier(node: ImportSpecifier) {
+            return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+        }
+    }
+}

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,19 @@
         "utilities.ts",
         "binder.ts",
         "checker.ts",
+        "factory.ts",
+        "visitor.ts",
+        "transformers/ts.ts",
+        "transformers/jsx.ts",
+        "transformers/es7.ts",
+        "transformers/es6.ts",
+        "transformers/generators.ts",
+        "transformers/destructuring.ts",
+        "transformers/module/module.ts",
+        "transformers/module/system.ts",
+        "transformers/module/es6.ts",
+        "transformer.ts",
+        "comments.ts",
         "sourcemap.ts",
         "declarationEmitter.ts",
         "emitter.ts",

src/compiler/types.ts

@@ -358,11 +358,18 @@ namespace ts {
 
         // Synthesized list
         SyntaxList,
+
+        // Transformation nodes
+        NotEmittedStatement,
+        PartiallyEmittedExpression,
+
         // Enum value count
         Count,
         // Markers
         FirstAssignment = EqualsToken,
         LastAssignment = CaretEqualsToken,
+        FirstCompoundAssignment = PlusEqualsToken,
+        LastCompoundAssignment = CaretEqualsToken,
         FirstReservedWord = BreakKeyword,
         LastReservedWord = WithKeyword,
         FirstKeyword = BreakKeyword,
@@ -391,6 +398,47 @@ namespace ts {
     }
 
     export const enum NodeFlags {
+        None =               0,
+        Let =                1 << 0,  // Variable declaration
+        Const =              1 << 1,  // Variable declaration
+        NestedNamespace =    1 << 2,  // Namespace declaration
+        Synthesized =        1 << 3,  // Node was synthesized during transformation
+        Namespace =          1 << 4,  // Namespace declaration
+        ExportContext =      1 << 5,  // Export context (initialized by binding)
+        ContainsThis =       1 << 6,  // Interface contains references to "this"
+        HasImplicitReturn =  1 << 7,  // If function implicitly returns on one of codepaths (initialized by binding)
+        HasExplicitReturn =  1 << 8,  // If function has explicit reachable return on one of codepaths (initialized by binding)
+        GlobalAugmentation = 1 << 9,  // Set if module declaration is an augmentation for the global scope
+        HasClassExtends =    1 << 10, // If the file has a non-ambient class with an extends clause in ES5 or lower (initialized by binding)
+        HasDecorators =      1 << 11, // If the file has decorators (initialized by binding)
+        HasParamDecorators = 1 << 12, // If the file has parameter decorators (initialized by binding)
+        HasAsyncFunctions =  1 << 13, // If the file has async functions (initialized by binding)
+        HasJsxSpreadAttributes = 1 << 14, // If the file as JSX spread attributes (initialized by binding)
+        DisallowInContext =  1 << 15, // If node was parsed in a context where 'in-expressions' are not allowed
+        YieldContext =       1 << 16, // If node was parsed in the 'yield' context created when parsing a generator
+        DecoratorContext =   1 << 17, // If node was parsed as part of a decorator
+        AwaitContext =       1 << 18, // If node was parsed in the 'await' context created when parsing an async function
+        ThisNodeHasError =   1 << 19, // If the parser encountered an error when parsing the code that created this node
+        JavaScriptFile =     1 << 20, // If node was parsed in a JavaScript
+        ThisNodeOrAnySubNodesHasError = 1 << 21, // If this node or any of its children had an error
+        HasAggregatedChildData = 1 << 22, // If we've computed data from children and cached it in this node
+
+        BlockScoped = Let | Const,
+
+        ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,
+        EmitHelperFlags = HasClassExtends | HasDecorators | HasParamDecorators | HasAsyncFunctions | HasJsxSpreadAttributes,
+        ReachabilityAndEmitFlags = ReachabilityCheckFlags | EmitHelperFlags,
+
+        // Parsing context flags
+        ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile,
+
+        // Exclude these flags when parsing a Type
+        TypeExcludesFlags = YieldContext | AwaitContext,
+    }
+
+    export type ModifiersArray = NodeArray<Modifier>;
+
+    export const enum ModifierFlags {
         None =               0,
         Export =             1 << 0,  // Declarations
         Ambient =            1 << 1,  // Declarations
@@ -402,43 +450,14 @@ namespace ts {
         Abstract =           1 << 7,  // Class/Method/ConstructSignature
         Async =              1 << 8,  // Property/Method/Function
         Default =            1 << 9,  // Function/Class (export default declaration)
-        Let =                1 << 10,  // Variable declaration
-        Const =              1 << 11,  // Variable declaration
-        Namespace =          1 << 12,  // Namespace declaration
-        ExportContext =      1 << 13,  // Export context (initialized by binding)
-        ContainsThis =       1 << 14,  // Interface contains references to "this"
-        HasImplicitReturn =  1 << 15,  // If function implicitly returns on one of codepaths (initialized by binding)
-        HasExplicitReturn =  1 << 16,  // If function has explicit reachable return on one of codepaths (initialized by binding)
-        GlobalAugmentation = 1 << 17,  // Set if module declaration is an augmentation for the global scope
-        HasClassExtends =    1 << 18,  // If the file has a non-ambient class with an extends clause in ES5 or lower (initialized by binding)
-        HasDecorators =      1 << 19,  // If the file has decorators (initialized by binding)
-        HasParamDecorators = 1 << 20,  // If the file has parameter decorators (initialized by binding)
-        HasAsyncFunctions =  1 << 21,  // If the file has async functions (initialized by binding)
-        DisallowInContext =  1 << 22,  // If node was parsed in a context where 'in-expressions' are not allowed
-        YieldContext =       1 << 23,  // If node was parsed in the 'yield' context created when parsing a generator
-        DecoratorContext =   1 << 24,  // If node was parsed as part of a decorator
-        AwaitContext =       1 << 25,  // If node was parsed in the 'await' context created when parsing an async function
-        ThisNodeHasError =   1 << 26,  // If the parser encountered an error when parsing the code that created this node
-        JavaScriptFile =     1 << 27,  // If node was parsed in a JavaScript
-        ThisNodeOrAnySubNodesHasError = 1 << 28,  // If this node or any of its children had an error
-        HasAggregatedChildData = 1 << 29,  // If we've computed data from children and cached it in this node
-        HasJsxSpreadAttribute = 1 << 30,
+        Const =              1 << 11, // Variable declaration
+
+        HasComputedFlags =   1 << 29, // Modifier flags have been computed
 
-        Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async | Readonly,
         AccessibilityModifier = Public | Private | Protected,
         // Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property.
         ParameterPropertyModifier = AccessibilityModifier | Readonly,
-        BlockScoped = Let | Const,
-
-        ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,
-        EmitHelperFlags = HasClassExtends | HasDecorators | HasParamDecorators | HasAsyncFunctions,
-        ReachabilityAndEmitFlags = ReachabilityCheckFlags | EmitHelperFlags,
-
-        // Parsing context flags
-        ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile,
-
-        // Exclude these flags when parsing a Type
-        TypeExcludesFlags = YieldContext | AwaitContext,
+        NonPublicAccessibilityModifier = Private | Protected,
     }
 
     export const enum JsxFlags {
@@ -461,26 +480,30 @@ namespace ts {
     export interface Node extends TextRange {
         kind: SyntaxKind;
         flags: NodeFlags;
+        /* @internal */ modifierFlagsCache?: ModifierFlags;
+        /* @internal */ transformFlags?: TransformFlags;
         decorators?: NodeArray<Decorator>;              // Array of decorators (in document order)
         modifiers?: ModifiersArray;                     // Array of modifiers
         /* @internal */ id?: number;                    // Unique id (used to look up NodeLinks)
-        parent?: Node;                                  // Parent node (initialized by binding
-        /* @internal */ jsDocComments?: JSDocComment[]; // JSDoc for the node, if it has any.  Only for .js files.
+        parent?: Node;                                  // Parent node (initialized by binding)
+        /* @internal */ original?: Node;                // The original node if this is an updated node.
+        /* @internal */ startsOnNewLine?: boolean;      // Whether a synthesized node should start on a new line (used by transforms).
+        /* @internal */ jsDocComments?: JSDoc[];        // JSDoc for the node, if it has any.
         /* @internal */ symbol?: Symbol;                // Symbol declared by node (initialized by binding)
         /* @internal */ locals?: SymbolTable;           // Locals associated with node (initialized by binding)
         /* @internal */ nextContainer?: Node;           // Next container in declaration order (initialized by binding)
         /* @internal */ localSymbol?: Symbol;           // Local symbol declared by node (initialized by binding only for exported nodes)
         /* @internal */ flowNode?: FlowNode;            // Associated FlowNode (initialized by binding)
+        /* @internal */ transformId?: number;           // Associates transient transformation properties with a specific transformation (initialized by transformation).
+        /* @internal */ emitFlags?: NodeEmitFlags;      // Transient emit flags for a synthesized node (initialized by transformation).
+        /* @internal */ sourceMapRange?: TextRange;     // Transient custom sourcemap range for a synthesized node (initialized by transformation).
+        /* @internal */ commentRange?: TextRange;       // Transient custom comment range for a synthesized node (initialized by transformation).
     }
 
-    export interface NodeArray<T> extends Array<T>, TextRange {
+    export interface NodeArray<T extends Node> extends Array<T>, TextRange {
         hasTrailingComma?: boolean;
     }
 
-    export interface ModifiersArray extends NodeArray<Modifier> {
-        flags: NodeFlags;
-    }
-
     export interface Token extends Node {
         __tokenTag: any;
     }
@@ -497,10 +520,26 @@ namespace ts {
     // @kind(SyntaxKind.StaticKeyword)
     export interface Modifier extends Token { }
 
+    /*@internal*/
+    export const enum GeneratedIdentifierKind {
+        None,   // Not automatically generated.
+        Auto,   // Automatically generated identifier.
+        Loop,   // Automatically generated identifier with a preference for '_i'.
+        Unique, // Unique name based on the 'text' property.
+        Node,   // Unique name based on the node in the 'original' property.
+    }
+
     // @kind(SyntaxKind.Identifier)
     export interface Identifier extends PrimaryExpression {
         text: string;                                  // Text of identifier (with escapes converted to characters)
         originalKeywordKind?: SyntaxKind;              // Original syntaxKind which get set so that we can report an error later
+        /*@internal*/ autoGenerateKind?: GeneratedIdentifierKind; // Specifies whether to auto-generate the text for an identifier.
+        /*@internal*/ autoGenerateId?: number;         // Ensures unique generated identifiers get unique names, but clones get the same name.
+    }
+
+    // Transient identifier node (marked by id === -1)
+    export interface TransientIdentifier extends Identifier {
+        resolvedSymbol: Symbol;
     }
 
     // @kind(SyntaxKind.QualifiedName)
@@ -557,10 +596,12 @@ namespace ts {
     // @kind(SyntaxKind.ConstructSignature)
     export interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement { }
 
+    export type BindingName = Identifier | BindingPattern;
+
     // @kind(SyntaxKind.VariableDeclaration)
     export interface VariableDeclaration extends Declaration {
         parent?: VariableDeclarationList;
-        name: Identifier | BindingPattern;  // Declared variable name
+        name: BindingName;                  // Declared variable name
         type?: TypeNode;                    // Optional type annotation
         initializer?: Expression;           // Optional initializer
     }
@@ -573,7 +614,7 @@ namespace ts {
     // @kind(SyntaxKind.Parameter)
     export interface ParameterDeclaration extends Declaration {
         dotDotDotToken?: Node;              // Present on rest parameter
-        name: Identifier | BindingPattern;  // Declared parameter name
+        name: BindingName;                  // Declared parameter name
         questionToken?: Node;               // Present on optional parameter
         type?: TypeNode;                    // Optional type annotation
         initializer?: Expression;           // Optional initializer
@@ -583,7 +624,7 @@ namespace ts {
     export interface BindingElement extends Declaration {
         propertyName?: PropertyName;        // Binding property name (in object binding pattern)
         dotDotDotToken?: Node;              // Present on rest binding element
-        name: Identifier | BindingPattern;  // Declared binding element name
+        name: BindingName;                  // Declared binding element name
         initializer?: Expression;           // Optional initializer
     }
 
@@ -648,14 +689,20 @@ namespace ts {
     }
 
     export interface BindingPattern extends Node {
-        elements: NodeArray<BindingElement>;
+        elements: NodeArray<BindingElement | ArrayBindingElement>;
     }
 
     // @kind(SyntaxKind.ObjectBindingPattern)
-    export interface ObjectBindingPattern extends BindingPattern { }
+    export interface ObjectBindingPattern extends BindingPattern {
+        elements: NodeArray<BindingElement>;
+    }
+
+    export type ArrayBindingElement = BindingElement | OmittedExpression;
 
     // @kind(SyntaxKind.ArrayBindingPattern)
-    export interface ArrayBindingPattern extends BindingPattern { }
+    export interface ArrayBindingPattern extends BindingPattern {
+        elements: NodeArray<ArrayBindingElement>;
+    }
 
     /**
      * Several node kinds share function-like features such as a signature,
@@ -811,6 +858,8 @@ namespace ts {
     // @kind(SyntaxKind.StringLiteral)
     export interface StringLiteral extends LiteralExpression {
         _stringLiteralBrand: any;
+        /* @internal */
+        textSourceNode?: Identifier | StringLiteral; // Allows a StringLiteral to get its text from another node (used by transforms).
     }
 
     // Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.
@@ -826,7 +875,17 @@ namespace ts {
     }
 
     // @kind(SyntaxKind.OmittedExpression)
-    export interface OmittedExpression extends Expression { }
+    export interface OmittedExpression extends Expression {
+        _omittedExpressionBrand: any;
+    }
+
+    // Represents an expression that is elided as part of a transformation to emit comments on a
+    // not-emitted node. The 'expression' property of a NotEmittedExpression should be emitted.
+    // @internal
+    // @kind(SyntaxKind.NotEmittedExpression)
+    export interface PartiallyEmittedExpression extends LeftHandSideExpression {
+        expression: Expression;
+    }
 
     export interface UnaryExpression extends Expression {
         _unaryExpressionBrand: any;
@@ -938,13 +997,18 @@ namespace ts {
     // The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,
     // or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.
     // For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".
-    // @kind(SyntaxKind.NumericLiteral)
     // @kind(SyntaxKind.RegularExpressionLiteral)
     // @kind(SyntaxKind.NoSubstitutionTemplateLiteral)
     export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {
         _literalExpressionBrand: any;
     }
 
+    // @kind(SyntaxKind.NumericLiteral)
+    export interface NumericLiteral extends LiteralExpression {
+        _numericLiteralBrand: any;
+        trailingComment?: string;
+    }
+
     // @kind(SyntaxKind.TemplateHead)
     // @kind(SyntaxKind.TemplateMiddle)
     // @kind(SyntaxKind.TemplateTail)
@@ -952,6 +1016,8 @@ namespace ts {
         _templateLiteralFragmentBrand: any;
     }
 
+    export type Template = TemplateExpression | LiteralExpression;
+
     // @kind(SyntaxKind.TemplateExpression)
     export interface TemplateExpression extends PrimaryExpression {
         head: TemplateLiteralFragment;
@@ -1030,7 +1096,7 @@ namespace ts {
     // @kind(SyntaxKind.TaggedTemplateExpression)
     export interface TaggedTemplateExpression extends MemberExpression {
         tag: LeftHandSideExpression;
-        template: LiteralExpression | TemplateExpression;
+        template: Template;
     }
 
     export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator;
@@ -1081,11 +1147,13 @@ namespace ts {
     /// Either the opening tag in a <Tag>...</Tag> pair, or the lone <Tag /> in a self-closing form
     export type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
 
+    export type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
+
     // @kind(SyntaxKind.JsxAttribute)
     export interface JsxAttribute extends Node {
         name: Identifier;
         /// JSX attribute initializers are optional; <X y /> is sugar for <X y={true} />
-        initializer?: Expression;
+        initializer?: StringLiteral | JsxExpression;
     }
 
     // @kind(SyntaxKind.JsxSpreadAttribute)
@@ -1114,6 +1182,13 @@ namespace ts {
         _statementBrand: any;
     }
 
+    // Represents a statement that is elided as part of a transformation to emit comments on a
+    // not-emitted node.
+    // @internal
+    // @kind(SyntaxKind.NotEmittedStatement)
+    export interface NotEmittedStatement extends Statement {
+    }
+
     // @kind(SyntaxKind.EmptyStatement)
     export interface EmptyStatement extends Statement { }
 
@@ -1130,6 +1205,7 @@ namespace ts {
     // @kind(SyntaxKind.Block)
     export interface Block extends Statement {
         statements: NodeArray<Statement>;
+        /*@internal*/ multiLine?: boolean;
     }
 
     // @kind(SyntaxKind.VariableStatement)
@@ -1163,22 +1239,24 @@ namespace ts {
         expression: Expression;
     }
 
+    export type ForInitializer = VariableDeclarationList | Expression;
+
     // @kind(SyntaxKind.ForStatement)
     export interface ForStatement extends IterationStatement {
-        initializer?: VariableDeclarationList | Expression;
+        initializer?: ForInitializer;
         condition?: Expression;
         incrementor?: Expression;
     }
 
     // @kind(SyntaxKind.ForInStatement)
     export interface ForInStatement extends IterationStatement {
-        initializer: VariableDeclarationList | Expression;
+        initializer: ForInitializer;
         expression: Expression;
     }
 
     // @kind(SyntaxKind.ForOfStatement)
     export interface ForOfStatement extends IterationStatement {
-        initializer: VariableDeclarationList | Expression;
+        initializer: ForInitializer;
         expression: Expression;
     }
 
@@ -1308,7 +1386,7 @@ namespace ts {
     export interface EnumMember extends Declaration {
         // This does include ComputedPropertyName, but the parser will give an error
         // if it parses a ComputedPropertyName in an EnumMember
-        name: DeclarationName;
+        name: PropertyName;
         initializer?: Expression;
     }
 
@@ -1320,6 +1398,8 @@ namespace ts {
 
     export type ModuleBody = ModuleBlock | ModuleDeclaration;
 
+    export type ModuleName = Identifier | StringLiteral;
+
     // @kind(SyntaxKind.ModuleDeclaration)
     export interface ModuleDeclaration extends DeclarationStatement {
         name: Identifier | LiteralExpression;
@@ -1331,13 +1411,15 @@ namespace ts {
         statements: NodeArray<Statement>;
     }
 
+    export type ModuleReference = EntityName | ExternalModuleReference;
+
     // @kind(SyntaxKind.ImportEqualsDeclaration)
     export interface ImportEqualsDeclaration extends DeclarationStatement {
         name: Identifier;
 
         // 'EntityName' for an internal module reference, 'ExternalModuleReference' for an external
         // module reference.
-        moduleReference: EntityName | ExternalModuleReference;
+        moduleReference: ModuleReference;
     }
 
     // @kind(SyntaxKind.ExternalModuleReference)
@@ -1355,6 +1437,8 @@ namespace ts {
         moduleSpecifier: Expression;
     }
 
+    export type NamedImportBindings = NamespaceImport | NamedImports;
+
     // In case of:
     // import d from "mod" => name = d, namedBinding = undefined
     // import * as ns from "mod" => name = undefined, namedBinding: NamespaceImport = { name: ns }
@@ -1364,7 +1448,7 @@ namespace ts {
     // @kind(SyntaxKind.ImportClause)
     export interface ImportClause extends Declaration {
         name?: Identifier; // Default binding
-        namedBindings?: NamespaceImport | NamedImports;
+        namedBindings?: NamedImportBindings;
     }
 
     // @kind(SyntaxKind.NamespaceImport)
@@ -1472,7 +1556,7 @@ namespace ts {
 
     // @kind(SyntaxKind.JSDocRecordType)
     export interface JSDocRecordType extends JSDocType, TypeLiteralNode {
-        members: NodeArray<JSDocRecordMember>;
+        literal: TypeLiteralNode;
     }
 
     // @kind(SyntaxKind.JSDocTypeReference)
@@ -1520,14 +1604,16 @@ namespace ts {
     }
 
     // @kind(SyntaxKind.JSDocComment)
-    export interface JSDocComment extends Node {
-        tags: NodeArray<JSDocTag>;
+    export interface JSDoc extends Node {
+        tags: NodeArray<JSDocTag> | undefined;
+        comment: string | undefined;
     }
 
     // @kind(SyntaxKind.JSDocTag)
     export interface JSDocTag extends Node {
         atToken: Node;
         tagName: Identifier;
+        comment: string | undefined;
     }
 
     // @kind(SyntaxKind.JSDocTemplateTag)
@@ -1566,9 +1652,13 @@ namespace ts {
 
     // @kind(SyntaxKind.JSDocParameterTag)
     export interface JSDocParameterTag extends JSDocTag {
+        /** the parameter name, if provided *before* the type (TypeScript-style) */
         preParameterName?: Identifier;
         typeExpression?: JSDocTypeExpression;
+        /** the parameter name, if provided *after* the type (JSDoc-standard) */
         postParameterName?: Identifier;
+        /** the parameter name, regardless of the location it was provided */
+        parameterName: Identifier;
         isBracketed: boolean;
     }
 
@@ -1703,6 +1793,8 @@ namespace ts {
         /* @internal */ imports: LiteralExpression[];
         /* @internal */ moduleAugmentations: LiteralExpression[];
         /* @internal */ patternAmbientModules?: PatternAmbientModule[];
+        // The synthesized identifier for an imported external helpers module.
+        /* @internal */ externalHelpersModuleName?: Identifier;
     }
 
     export interface ScriptReferenceHost {
@@ -1722,6 +1814,8 @@ namespace ts {
           * @param path The path to test.
           */
         fileExists(path: string): boolean;
+
+        readFile(path: string): string;
     }
 
     export interface WriteFileCallback {
@@ -2023,12 +2117,13 @@ namespace ts {
                                             // function that can be reached at runtime (e.g. a `class`
                                             // declaration or a `var` declaration for the static side
                                             // of a type, such as the global `Promise` type in lib.d.ts).
-        VoidType,                           // The TypeReferenceNode resolves to a Void-like type.
+        VoidNullableOrNeverType,            // The TypeReferenceNode resolves to a Void-like, Nullable, or Never type.
         NumberLikeType,                     // The TypeReferenceNode resolves to a Number-like type.
         StringLikeType,                     // The TypeReferenceNode resolves to a String-like type.
         BooleanType,                        // The TypeReferenceNode resolves to a Boolean-like type.
         ArrayLikeType,                      // The TypeReferenceNode resolves to an Array-like type.
         ESSymbolType,                       // The TypeReferenceNode resolves to the ESSymbol type.
+        Promise,                            // The TypeReferenceNode resolved to the global Promise constructor symbol.
         TypeWithCallSignature,              // The TypeReferenceNode resolves to a Function type or a type
                                             // with call signatures.
         ObjectType,                         // The TypeReferenceNode resolves to any other type.
@@ -2037,7 +2132,7 @@ namespace ts {
     /* @internal */
     export interface EmitResolver {
         hasGlobalName(name: string): boolean;
-        getReferencedExportContainer(node: Identifier): SourceFile | ModuleDeclaration | EnumDeclaration;
+        getReferencedExportContainer(node: Identifier, prefixLocals?: boolean): SourceFile | ModuleDeclaration | EnumDeclaration;
         getReferencedImportDeclaration(node: Identifier): Declaration;
         getReferencedDeclarationWithCollidingName(node: Identifier): Declaration;
         isDeclarationWithCollidingName(node: Declaration): boolean;
@@ -2052,12 +2147,12 @@ namespace ts {
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
-        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessibilityResult;
+        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
         getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
         getReferencedValueDeclaration(reference: Identifier): Declaration;
-        getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind;
+        getTypeReferenceSerializationKind(typeName: EntityName, location?: Node): TypeReferenceSerializationKind;
         isOptionalParameter(node: ParameterDeclaration): boolean;
         moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean;
         isArgumentsLocalBinding(node: Identifier): boolean;
@@ -2232,6 +2327,8 @@ namespace ts {
         BodyScopedClassBinding              = 0x00100000,  // Binding to a decorated class inside of the class's body.
         NeedsLoopOutParameter               = 0x00200000,  // Block scoped binding whose value should be explicitly copied outside of the converted loop
         AssignmentsMarked                   = 0x00400000,  // Parameter assignments have been marked
+        ClassWithConstructorReference       = 0x00800000,  // Class that contains a binding to its constructor inside of the class body.
+        ConstructorReferenceInClass         = 0x01000000,  // Binding to a class constructor inside of the class's body.
     }
 
     /* @internal */
@@ -2507,13 +2604,14 @@ namespace ts {
     export interface TypeInferences {
         primary: Type[];    // Inferences made directly to a type parameter
         secondary: Type[];  // Inferences made to a type parameter in a union type
+        topLevel: boolean;  // True if all inferences were made from top-level (not nested in object type) locations
         isFixed: boolean;   // Whether the type parameter is fixed, as defined in section 4.12.2 of the TypeScript spec
                             // If a type parameter is fixed, no more inferences can be made for the type parameter
     }
 
     /* @internal */
     export interface InferenceContext {
-        typeParameters: TypeParameter[];    // Type parameters for which inferences are made
+        signature: Signature;               // Generic signature for which inferences are made
         inferUnionTypes: boolean;           // Infer union types for disjoint candidates (otherwise undefinedType)
         inferences: TypeInferences[];       // Inferences made for each type parameter
         inferredTypes: Type[];              // Inferred type for each type parameter
@@ -2600,6 +2698,7 @@ namespace ts {
         experimentalDecorators?: boolean;
         forceConsistentCasingInFileNames?: boolean;
         /*@internal*/help?: boolean;
+        importHelpers?: boolean;
         /*@internal*/init?: boolean;
         inlineSourceMap?: boolean;
         inlineSources?: boolean;
@@ -2988,8 +3087,117 @@ namespace ts {
          * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
          */
         resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
+        getEnvironmentVariable?(name: string): string;
     }
 
+    /* @internal */
+    export const enum TransformFlags {
+        None = 0,
+
+        // Facts
+        // - Flags used to indicate that a node or subtree contains syntax that requires transformation.
+        TypeScript = 1 << 0,
+        ContainsTypeScript = 1 << 1,
+        Jsx = 1 << 2,
+        ContainsJsx = 1 << 3,
+        ES7 = 1 << 4,
+        ContainsES7 = 1 << 5,
+        ES6 = 1 << 6,
+        ContainsES6 = 1 << 7,
+        DestructuringAssignment = 1 << 8,
+        Generator = 1 << 9,
+        ContainsGenerator = 1 << 10,
+
+        // Markers
+        // - Flags used to indicate that a subtree contains a specific transformation.
+        ContainsDecorators = 1 << 11,
+        ContainsPropertyInitializer = 1 << 12,
+        ContainsLexicalThis = 1 << 13,
+        ContainsCapturedLexicalThis = 1 << 14,
+        ContainsLexicalThisInComputedPropertyName = 1 << 15,
+        ContainsDefaultValueAssignments = 1 << 16,
+        ContainsParameterPropertyAssignments = 1 << 17,
+        ContainsSpreadElementExpression = 1 << 18,
+        ContainsComputedPropertyName = 1 << 19,
+        ContainsBlockScopedBinding = 1 << 20,
+        ContainsBindingPattern = 1 << 21,
+        ContainsYield = 1 << 22,
+        ContainsHoistedDeclarationOrCompletion = 1 << 23,
+
+        HasComputedFlags = 1 << 29, // Transform flags have been computed.
+
+        // Assertions
+        // - Bitmasks that are used to assert facts about the syntax of a node and its subtree.
+        AssertTypeScript = TypeScript | ContainsTypeScript,
+        AssertJsx = Jsx | ContainsJsx,
+        AssertES7 = ES7 | ContainsES7,
+        AssertES6 = ES6 | ContainsES6,
+        AssertGenerator = Generator | ContainsGenerator,
+
+        // Scope Exclusions
+        // - Bitmasks that exclude flags from propagating out of a specific context
+        //   into the subtree flags of their container.
+        NodeExcludes = TypeScript | Jsx | ES7 | ES6 | DestructuringAssignment | Generator | HasComputedFlags,
+        ArrowFunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
+        FunctionExcludes = NodeExcludes | ContainsDecorators | ContainsDefaultValueAssignments | ContainsCapturedLexicalThis | ContainsLexicalThis | ContainsParameterPropertyAssignments | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
+        ConstructorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
+        MethodOrAccessorExcludes = NodeExcludes | ContainsDefaultValueAssignments | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsYield | ContainsHoistedDeclarationOrCompletion,
+        ClassExcludes = NodeExcludes | ContainsDecorators | ContainsPropertyInitializer | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsComputedPropertyName | ContainsParameterPropertyAssignments | ContainsLexicalThisInComputedPropertyName,
+        ModuleExcludes = NodeExcludes | ContainsDecorators | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsHoistedDeclarationOrCompletion,
+        TypeExcludes = ~ContainsTypeScript,
+        ObjectLiteralExcludes = NodeExcludes | ContainsDecorators | ContainsComputedPropertyName | ContainsLexicalThisInComputedPropertyName,
+        ArrayLiteralOrCallOrNewExcludes = NodeExcludes | ContainsSpreadElementExpression,
+        VariableDeclarationListExcludes = NodeExcludes | ContainsBindingPattern,
+        ParameterExcludes = NodeExcludes | ContainsBindingPattern,
+
+        // Masks
+        // - Additional bitmasks
+        TypeScriptClassSyntaxMask = ContainsParameterPropertyAssignments | ContainsPropertyInitializer | ContainsDecorators,
+        ES6FunctionSyntaxMask = ContainsCapturedLexicalThis | ContainsDefaultValueAssignments,
+    }
+
+    /* @internal */
+    export const enum NodeEmitFlags {
+        EmitEmitHelpers = 1 << 0,                // Any emit helpers should be written to this node.
+        EmitExportStar = 1 << 1,                 // The export * helper should be written to this node.
+        EmitSuperHelper = 1 << 2,                // Emit the basic _super helper for async methods.
+        EmitAdvancedSuperHelper = 1 << 3,        // Emit the advanced _super helper for async methods.
+        UMDDefine = 1 << 4,                      // This node should be replaced with the UMD define helper.
+        SingleLine = 1 << 5,                     // The contents of this node should be emitted on a single line.
+        AdviseOnEmitNode = 1 << 6,               // The printer should invoke the onEmitNode callback when printing this node.
+        NoSubstitution = 1 << 7,                 // Disables further substitution of an expression.
+        CapturesThis = 1 << 8,                   // The function captures a lexical `this`
+        NoLeadingSourceMap = 1 << 9,             // Do not emit a leading source map location for this node.
+        NoTrailingSourceMap = 1 << 10,           // Do not emit a trailing source map location for this node.
+        NoSourceMap = NoLeadingSourceMap | NoTrailingSourceMap, // Do not emit a source map location for this node.
+        NoNestedSourceMaps = 1 << 11,            // Do not emit source map locations for children of this node.
+        NoTokenLeadingSourceMaps = 1 << 12,      // Do not emit leading source map location for token nodes.
+        NoTokenTrailingSourceMaps = 1 << 13,     // Do not emit trailing source map location for token nodes.
+        NoTokenSourceMaps = NoTokenLeadingSourceMaps | NoTokenTrailingSourceMaps, // Do not emit source map locations for tokens of this node.
+        NoLeadingComments = 1 << 14,             // Do not emit leading comments for this node.
+        NoTrailingComments = 1 << 15,            // Do not emit trailing comments for this node.
+        NoComments = NoLeadingComments | NoTrailingComments, // Do not emit comments for this node.
+        NoNestedComments = 1 << 16,
+        ExportName = 1 << 17,                    // Ensure an export prefix is added for an identifier that points to an exported declaration with a local name (see SymbolFlags.ExportHasLocal).
+        LocalName = 1 << 18,                     // Ensure an export prefix is not added for an identifier that points to an exported declaration.
+        Indented = 1 << 19,                      // Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter).
+        NoIndentation = 1 << 20,                 // Do not indent the node.
+        AsyncFunctionBody = 1 << 21,
+        ReuseTempVariableScope = 1 << 22,        // Reuse the existing temp variable scope during emit.
+        CustomPrologue = 1 << 23,                // Treat the statement as if it were a prologue directive (NOTE: Prologue directives are *not* transformed).
+    }
+
+    /** Additional context provided to `visitEachChild` */
+    /* @internal */
+    export interface LexicalEnvironment {
+        /** Starts a new lexical environment. */
+        startLexicalEnvironment(): void;
+
+        /** Ends a lexical environment, returning any declarations. */
+        endLexicalEnvironment(): Statement[];
+    }
+
+
     export interface TextSpan {
         start: number;
         length: number;

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/fourslash.ts

@@ -88,6 +88,10 @@ namespace FourSlash {
         marker?: Marker;
     }
 
+    interface ImplementationLocationInformation extends ts.ImplementationLocation {
+        matched?: boolean;
+    }
+
     export interface TextSpan {
         start: number;
         end: number;
@@ -347,23 +351,25 @@ namespace FourSlash {
             }
 
             this.formatCodeSettings = {
-                baseIndentSize: 0,
-                indentSize: 4,
-                tabSize: 4,
-                newLineCharacter: Harness.IO.newLine(),
-                convertTabsToSpaces: true,
-                indentStyle: ts.IndentStyle.Smart,
-                insertSpaceAfterCommaDelimiter: true,
-                insertSpaceAfterSemicolonInForStatements: true,
-                insertSpaceBeforeAndAfterBinaryOperators: true,
-                insertSpaceAfterKeywordsInControlFlowStatements: true,
-                insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
-                insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
-                insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
-                insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
-                insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
-                placeOpenBraceOnNewLineForFunctions: false,
-                placeOpenBraceOnNewLineForControlBlocks: false,
+                BaseIndentSize: 0,
+                IndentSize: 4,
+                TabSize: 4,
+                NewLineCharacter: Harness.IO.newLine(),
+                ConvertTabsToSpaces: true,
+                IndentStyle: ts.IndentStyle.Smart,
+                InsertSpaceAfterCommaDelimiter: true,
+                InsertSpaceAfterSemicolonInForStatements: true,
+                InsertSpaceBeforeAndAfterBinaryOperators: true,
+                InsertSpaceAfterKeywordsInControlFlowStatements: true,
+                InsertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
+                InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
+                InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+                InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+                InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
+                InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+                InsertSpaceAfterTypeAssertion: false,
+                PlaceOpenBraceOnNewLineForFunctions: false,
+                PlaceOpenBraceOnNewLineForControlBlocks: false,
             };
 
             // Open the first file by default
@@ -543,6 +549,67 @@ namespace FourSlash {
             }
         }
 
+        public verifyGoToDefinitionIs(endMarker: string | string[]) {
+            this.verifyGoToDefinitionWorker(endMarker instanceof Array ? endMarker : [endMarker]);
+        }
+
+        public verifyGoToDefinition(arg0: any, endMarkerNames?: string | string[]) {
+            if (endMarkerNames) {
+                this.verifyGoToDefinitionPlain(arg0, endMarkerNames);
+            }
+            else if (arg0 instanceof Array) {
+                const pairs: [string | string[], string | string[]][] = arg0;
+                for (const [start, end] of pairs) {
+                    this.verifyGoToDefinitionPlain(start, end);
+                }
+            }
+            else {
+                const obj: { [startMarkerName: string]: string | string[] } = arg0;
+                for (const startMarkerName in obj) {
+                    if (ts.hasProperty(obj, startMarkerName)) {
+                        this.verifyGoToDefinitionPlain(startMarkerName, obj[startMarkerName]);
+                    }
+                }
+            }
+        }
+
+        private verifyGoToDefinitionPlain(startMarkerNames: string | string[], endMarkerNames: string | string[]) {
+            if (startMarkerNames instanceof Array) {
+                for (const start of startMarkerNames) {
+                    this.verifyGoToDefinitionSingle(start, endMarkerNames);
+                }
+            }
+            else {
+                this.verifyGoToDefinitionSingle(startMarkerNames, endMarkerNames);
+            }
+        }
+
+        public verifyGoToDefinitionForMarkers(markerNames: string[]) {
+            for (const markerName of markerNames) {
+                this.verifyGoToDefinitionSingle(`${markerName}Reference`, `${markerName}Definition`);
+            }
+        }
+
+        private verifyGoToDefinitionSingle(startMarkerName: string, endMarkerNames: string | string[]) {
+            this.goToMarker(startMarkerName);
+            this.verifyGoToDefinitionWorker(endMarkerNames instanceof Array ? endMarkerNames : [endMarkerNames]);
+        }
+
+        private verifyGoToDefinitionWorker(endMarkers: string[]) {
+            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition) || [];
+
+            if (endMarkers.length !== definitions.length) {
+                this.raiseError(`goToDefinitions failed - expected to find ${endMarkers.length} definitions but got ${definitions.length}`);
+            }
+
+            for (let i = 0; i < endMarkers.length; i++) {
+                const marker = this.getMarkerByName(endMarkers[i]), definition = definitions[i];
+                if (marker.fileName !== definition.fileName || marker.position !== definition.textSpan.start) {
+                    this.raiseError(`goToDefinition failed for definition ${i}: expected ${marker.fileName} at ${marker.position}, got ${definition.fileName} at ${definition.textSpan.start}`);
+                }
+            }
+        }
+
         public verifyGetEmitOutputForCurrentFile(expected: string): void {
             const emit = this.languageService.getEmitOutput(this.activeFile.fileName);
             if (emit.outputFiles.length !== 1) {
@@ -892,29 +959,35 @@ namespace FourSlash {
             assert.equal(actual, expected);
         }
 
-        public verifyQuickInfoString(negative: boolean, expectedText?: string, expectedDocumentation?: string) {
+        public verifyQuickInfoAt(markerName: string, expectedText: string, expectedDocumentation?: string) {
+            this.goToMarker(markerName);
+            this.verifyQuickInfoString(expectedText, expectedDocumentation);
+        }
+
+        public verifyQuickInfos(namesAndTexts: { [name: string]: string | [string, string] }) {
+            ts.forEachProperty(ts.createMap(namesAndTexts), (text, name) => {
+                if (text instanceof Array) {
+                    assert(text.length === 2);
+                    const [expectedText, expectedDocumentation] = text;
+                    this.verifyQuickInfoAt(name, expectedText, expectedDocumentation);
+                }
+                else {
+                    this.verifyQuickInfoAt(name, text);
+                }
+            });
+        }
+
+        public verifyQuickInfoString(expectedText: string, expectedDocumentation?: string) {
+            if (expectedDocumentation === "") {
+                throw new Error("Use 'undefined' instead");
+            }
+
             const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             const actualQuickInfoText = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.displayParts) : "";
             const actualQuickInfoDocumentation = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.documentation) : "";
 
-            if (negative) {
-                if (expectedText !== undefined) {
-                    assert.notEqual(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
-                }
-                // TODO: should be '==='?
-                if (expectedDocumentation != undefined) {
-                    assert.notEqual(actualQuickInfoDocumentation, expectedDocumentation, this.messageAtLastKnownMarker("quick info doc comment"));
-                }
-            }
-            else {
-                if (expectedText !== undefined) {
-                    assert.equal(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
-                }
-                // TODO: should be '==='?
-                if (expectedDocumentation != undefined) {
-                    assert.equal(actualQuickInfoDocumentation, expectedDocumentation, this.assertionMessageAtLastKnownMarker("quick info doc"));
-                }
-            }
+            assert.equal(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
+            assert.equal(actualQuickInfoDocumentation, expectedDocumentation || "", this.assertionMessageAtLastKnownMarker("quick info doc"));
         }
 
         public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; },
@@ -1232,6 +1305,22 @@ namespace FourSlash {
                 });
         }
 
+        public baselineQuickInfo() {
+            let baselineFile = this.testData.globalOptions[metadataOptionNames.baselineFile];
+            if (!baselineFile) {
+                baselineFile = ts.getBaseFileName(this.activeFile.fileName).replace(".ts", ".baseline");
+            }
+
+            Harness.Baseline.runBaseline(
+                baselineFile,
+                () => stringify(
+                    this.testData.markers.map(marker => ({
+                        marker,
+                        quickInfo: this.languageService.getQuickInfoAtPosition(marker.fileName, marker.position)
+                    }))
+                ));
+        }
+
         public printBreakpointLocation(pos: number) {
             Harness.IO.log("\n**Pos: " + pos + " " + this.spanInfoToString(pos, this.getBreakpointStatementLocation(pos), "  "));
         }
@@ -1590,25 +1679,10 @@ namespace FourSlash {
             this.goToPosition(len);
         }
 
-        public goToDefinition(definitionIndex: number) {
-            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            if (!definitions || !definitions.length) {
-                this.raiseError("goToDefinition failed - expected to at least one definition location but got 0");
-            }
-
-            if (definitionIndex >= definitions.length) {
-                this.raiseError(`goToDefinition failed - definitionIndex value (${definitionIndex}) exceeds definition list size (${definitions.length})`);
-            }
-
-            const definition = definitions[definitionIndex];
-            this.openFile(definition.fileName);
-            this.currentCaretPosition = definition.textSpan.start;
-        }
-
         public goToTypeDefinition(definitionIndex: number) {
             const definitions = this.languageService.getTypeDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             if (!definitions || !definitions.length) {
-                this.raiseError("goToTypeDefinition failed - expected to at least one definition location but got 0");
+                this.raiseError("goToTypeDefinition failed - expected to find at least one definition location but got 0");
             }
 
             if (definitionIndex >= definitions.length) {
@@ -1620,28 +1694,6 @@ namespace FourSlash {
             this.currentCaretPosition = definition.textSpan.start;
         }
 
-        public verifyDefinitionLocationExists(negative: boolean) {
-            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-
-            const foundDefinitions = definitions && definitions.length;
-
-            if (foundDefinitions && negative) {
-                this.raiseError(`goToDefinition - expected to 0 definition locations but got ${definitions.length}`);
-            }
-            else if (!foundDefinitions && !negative) {
-                this.raiseError("goToDefinition - expected to at least one definition location but got 0");
-            }
-        }
-
-        public verifyDefinitionsCount(negative: boolean, expectedCount: number) {
-            const assertFn = negative ? assert.notEqual : assert.equal;
-
-            const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
-            const actualCount = definitions && definitions.length || 0;
-
-            assertFn(actualCount, expectedCount, this.messageAtLastKnownMarker("Definitions Count"));
-        }
-
         public verifyTypeDefinitionsCount(negative: boolean, expectedCount: number) {
             const assertFn = negative ? assert.notEqual : assert.equal;
 
@@ -1651,17 +1703,98 @@ namespace FourSlash {
             assertFn(actualCount, expectedCount, this.messageAtLastKnownMarker("Type definitions Count"));
         }
 
-        public verifyDefinitionsName(negative: boolean, expectedName: string, expectedContainerName: string) {
+        public verifyImplementationListIsEmpty(negative: boolean) {
+            const implementations = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+
+            if (negative) {
+                assert.isTrue(implementations && implementations.length > 0, "Expected at least one implementation but got 0");
+            }
+            else {
+                assert.isUndefined(implementations, "Expected implementation list to be empty but implementations returned");
+            }
+        }
+
+        public verifyGoToDefinitionName(expectedName: string, expectedContainerName: string) {
             const definitions = this.languageService.getDefinitionAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             const actualDefinitionName = definitions && definitions.length ? definitions[0].name : "";
             const actualDefinitionContainerName = definitions && definitions.length ? definitions[0].containerName : "";
-            if (negative) {
-                assert.notEqual(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
-                assert.notEqual(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
+            assert.equal(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
+            assert.equal(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
+        }
+
+        public goToImplementation() {
+            const implementations = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            if (!implementations || !implementations.length) {
+                this.raiseError("goToImplementation failed - expected to find at least one implementation location but got 0");
             }
-            else {
-                assert.equal(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name"));
-                assert.equal(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name"));
+            if (implementations.length > 1) {
+                this.raiseError(`goToImplementation failed - more than 1 implementation returned (${implementations.length})`);
+            }
+
+            const implementation = implementations[0];
+            this.openFile(implementation.fileName);
+            this.currentCaretPosition = implementation.textSpan.start;
+        }
+
+        public verifyRangesInImplementationList(markerName: string) {
+            this.goToMarker(markerName);
+            const implementations: ImplementationLocationInformation[] = this.languageService.getImplementationAtPosition(this.activeFile.fileName, this.currentCaretPosition);
+            if (!implementations || !implementations.length) {
+                this.raiseError("verifyRangesInImplementationList failed - expected to find at least one implementation location but got 0");
+            }
+
+            for (let i = 0; i < implementations.length; i++) {
+                for (let j = 0; j < implementations.length; j++) {
+                    if (i !== j && implementationsAreEqual(implementations[i], implementations[j])) {
+                        const { textSpan, fileName } = implementations[i];
+                        const end = textSpan.start + textSpan.length;
+                        this.raiseError(`Duplicate implementations returned for range (${textSpan.start}, ${end}) in ${fileName}`);
+                    }
+                }
+            }
+
+            const ranges = this.getRanges();
+
+            if (!ranges || !ranges.length) {
+                this.raiseError("verifyRangesInImplementationList failed - expected to find at least one range in test source");
+            }
+
+            const unsatisfiedRanges: Range[] = [];
+
+            for (const range of ranges) {
+                const length = range.end - range.start;
+                const matchingImpl = ts.find(implementations, impl =>
+                    range.fileName === impl.fileName && range.start === impl.textSpan.start && length === impl.textSpan.length);
+                if (matchingImpl) {
+                    matchingImpl.matched = true;
+                }
+                else {
+                    unsatisfiedRanges.push(range);
+                }
+            }
+
+            const unmatchedImplementations = implementations.filter(impl => !impl.matched);
+            if (unmatchedImplementations.length || unsatisfiedRanges.length) {
+                let error = "Not all ranges or implementations are satisfied";
+                if (unsatisfiedRanges.length) {
+                    error += "\nUnsatisfied ranges:";
+                    for (const range of unsatisfiedRanges) {
+                        error += `\n    (${range.start}, ${range.end}) in ${range.fileName}: ${this.rangeText(range)}`;
+                    }
+                }
+
+                if (unmatchedImplementations.length) {
+                    error += "\nUnmatched implementations:";
+                    for (const impl of unmatchedImplementations) {
+                        const end = impl.textSpan.start + impl.textSpan.length;
+                        error += `\n    (${impl.textSpan.start}, ${end}) in ${impl.fileName}: ${this.getFileContent(impl.fileName).slice(impl.textSpan.start, end)}`;
+                    }
+                }
+                this.raiseError(error);
+            }
+
+            function implementationsAreEqual(a: ImplementationLocationInformation, b: ImplementationLocationInformation) {
+                return a.fileName === b.fileName && TestState.textSpansEqual(a.textSpan, b.textSpan);
             }
         }
 
@@ -1670,6 +1803,10 @@ namespace FourSlash {
             return this.testData.markers.slice(0);
         }
 
+        public getMarkerNames(): string[] {
+            return Object.keys(this.testData.markerPositions);
+        }
+
         public getRanges(): Range[] {
             return this.testData.ranges;
         }
@@ -1678,8 +1815,7 @@ namespace FourSlash {
             const result = ts.createMap<Range[]>();
             for (const range of this.getRanges()) {
                 const text = this.rangeText(range);
-                const ranges = result[text] || (result[text] = []);
-                ranges.push(range);
+                ts.multiMapAdd(result, text, range);
             }
             return result;
         }
@@ -1991,11 +2127,12 @@ namespace FourSlash {
         }
 
         /*
-            Check number of navigationItems which match both searchValue and matchKind.
+            Check number of navigationItems which match both searchValue and matchKind,
+            if a filename is passed in, limit the results to that file.
             Report an error if expected value and actual value do not match.
         */
-        public verifyNavigationItemsCount(expected: number, searchValue: string, matchKind?: string) {
-            const items = this.languageService.getNavigateToItems(searchValue);
+        public verifyNavigationItemsCount(expected: number, searchValue: string, matchKind?: string, fileName?: string) {
+            const items = this.languageService.getNavigateToItems(searchValue, /*maxResultCount*/ undefined, fileName);
             let actual = 0;
             let item: ts.NavigateToItem;
 
@@ -2794,6 +2931,10 @@ namespace FourSlashInterface {
             return this.state.getMarkers();
         }
 
+        public markerNames(): string[] {
+            return this.state.getMarkerNames();
+        }
+
         public marker(name?: string): FourSlash.Marker {
             return this.state.getMarkerByName(name);
         }
@@ -2829,14 +2970,14 @@ namespace FourSlashInterface {
             this.state.goToEOF();
         }
 
-        public definition(definitionIndex = 0) {
-            this.state.goToDefinition(definitionIndex);
-        }
-
         public type(definitionIndex = 0) {
             this.state.goToTypeDefinition(definitionIndex);
         }
 
+        public implementation() {
+            this.state.goToImplementation();
+        }
+
         public position(position: number, fileIndex?: number): void;
         public position(position: number, fileName?: string): void;
         public position(position: number, fileNameOrIndex?: any): void {
@@ -2929,28 +3070,16 @@ namespace FourSlashInterface {
             this.state.verifyErrorExistsAfterMarker(markerName, !this.negative, /*after*/ false);
         }
 
-        public quickInfoIs(expectedText?: string, expectedDocumentation?: string) {
-            this.state.verifyQuickInfoString(this.negative, expectedText, expectedDocumentation);
-        }
-
         public quickInfoExists() {
             this.state.verifyQuickInfoExists(this.negative);
         }
 
-        public definitionCountIs(expectedCount: number) {
-            this.state.verifyDefinitionsCount(this.negative, expectedCount);
-        }
-
         public typeDefinitionCountIs(expectedCount: number) {
             this.state.verifyTypeDefinitionsCount(this.negative, expectedCount);
         }
 
-        public definitionLocationExists() {
-            this.state.verifyDefinitionLocationExists(this.negative);
-        }
-
-        public verifyDefinitionsName(name: string, containerName: string) {
-            this.state.verifyDefinitionsName(this.negative, name, containerName);
+        public implementationListIsEmpty() {
+            this.state.verifyImplementationListIsEmpty(this.negative);
         }
 
         public isValidBraceCompletionAtPosition(openingBrace: string) {
@@ -2963,6 +3092,18 @@ namespace FourSlashInterface {
             super(state);
         }
 
+        public quickInfoIs(expectedText: string, expectedDocumentation?: string) {
+            this.state.verifyQuickInfoString(expectedText, expectedDocumentation);
+        }
+
+        public quickInfoAt(markerName: string, expectedText?: string, expectedDocumentation?: string) {
+            this.state.verifyQuickInfoAt(markerName, expectedText, expectedDocumentation);
+        }
+
+        public quickInfos(namesAndTexts: { [name: string]: string }) {
+            this.state.verifyQuickInfos(namesAndTexts);
+        }
+
         public caretAtMarker(markerName?: string) {
             this.state.verifyCaretAtMarker(markerName);
         }
@@ -2996,6 +3137,25 @@ namespace FourSlashInterface {
             this.state.verifyCurrentFileContent(text);
         }
 
+        public goToDefinitionIs(endMarkers: string | string[]) {
+            this.state.verifyGoToDefinitionIs(endMarkers);
+        }
+
+        public goToDefinition(startMarkerName: string | string[], endMarkerName: string | string[]): void;
+        public goToDefinition(startsAndEnds: [string | string[], string | string[]][]): void;
+        public goToDefinition(startsAndEnds: { [startMarkerName: string]: string | string[] }): void;
+        public goToDefinition(arg0: any, endMarkerName?: string | string[]) {
+            this.state.verifyGoToDefinition(arg0, endMarkerName);
+        }
+
+        public goToDefinitionForMarkers(...markerNames: string[]) {
+            this.state.verifyGoToDefinitionForMarkers(markerNames);
+        }
+
+        public goToDefinitionName(name: string, containerName: string) {
+            this.state.verifyGoToDefinitionName(name, containerName);
+        }
+
         public verifyGetEmitOutputForCurrentFile(expected: string): void {
             this.state.verifyGetEmitOutputForCurrentFile(expected);
         }
@@ -3072,6 +3232,10 @@ namespace FourSlashInterface {
             this.state.baselineGetEmitOutput();
         }
 
+        public baselineQuickInfo() {
+            this.state.baselineQuickInfo();
+        }
+
         public nameOrDottedNameSpanTextIs(text: string) {
             this.state.verifyCurrentNameOrDottedNameSpanText(text);
         }
@@ -3104,8 +3268,8 @@ namespace FourSlashInterface {
             this.state.verifyNavigationBar(json);
         }
 
-        public navigationItemsListCount(count: number, searchValue: string, matchKind?: string) {
-            this.state.verifyNavigationItemsCount(count, searchValue, matchKind);
+        public navigationItemsListCount(count: number, searchValue: string, matchKind?: string, fileName?: string) {
+            this.state.verifyNavigationItemsCount(count, searchValue, matchKind, fileName);
         }
 
         public navigationItemsListContains(
@@ -3186,6 +3350,10 @@ namespace FourSlashInterface {
         public ProjectInfo(expected: string[]) {
             this.state.verifyProjectInfo(expected);
         }
+
+        public allRangesAppearInImplementationList(markerName: string) {
+            this.state.verifyRangesInImplementationList(markerName);
+        }
     }
 
     export class Edit {

src/harness/harness.ts

@@ -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,6 +506,8 @@ 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;
 
@@ -493,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) {
@@ -562,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) {
@@ -713,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);
@@ -787,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;
@@ -1333,7 +1407,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 */
@@ -1484,7 +1558,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 */
@@ -1651,7 +1725,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);
                 }
             }
@@ -1770,7 +1844,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
@@ -1788,7 +1863,7 @@ namespace Harness {
                     tsConfig.options.configFilePath = data.name;
 
                     // delete entry from the list
-                    testUnitData.splice(i, 1);
+                    ts.orderedRemoveItemAt(testUnitData, i);
 
                     break;
                 }
@@ -1908,9 +1983,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

@@ -411,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));
         }
@@ -435,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));
         }
@@ -489,6 +495,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({}); }
     }
 
@@ -643,6 +652,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.");
         }

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;

src/harness/tsconfig.json

@@ -22,6 +22,19 @@
         "../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/es7.ts",
+        "../compiler/transformers/es6.ts",
+        "../compiler/transformers/generators.ts",
+        "../compiler/transformers/destructuring.ts",
+        "../compiler/transformers/module/module.ts",
+        "../compiler/transformers/module/system.ts",
+        "../compiler/transformers/module/es6.ts",
+        "../compiler/transformer.ts",
+        "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
         "../compiler/emitter.ts",
@@ -86,6 +99,7 @@
         "./unittests/moduleResolution.ts",
         "./unittests/tsconfigParsing.ts",
         "./unittests/commandLineParsing.ts",
+        "./unittests/configurationExtension.ts",
         "./unittests/convertCompilerOptionsFromJson.ts",
         "./unittests/convertTypingOptionsFromJson.ts",
         "./unittests/tsserverProjectSystem.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");
             },

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/session.ts

@@ -18,6 +18,7 @@ namespace ts.server {
         createDirectory(): void {},
         getExecutingFilePath(): string { return void 0; },
         getCurrentDirectory(): string { return void 0; },
+        getEnvironmentVariable(name: string): string { return ""; },
         readDirectory(): string[] { return []; },
         exit(): void { },
         setTimeout(callback, ms, ...args) { return 0; },

src/harness/unittests/transpile.ts

@@ -101,7 +101,6 @@ namespace ts {
                     });
                 });
 
-
                 if (canUseOldTranspile) {
                     it("Correct output (old transpile) for " + justName, () => {
                         Harness.Baseline.runBaseline(justName.replace(/\.tsx?$/, ".oldTranspile.js"), () => {

src/harness/unittests/tsconfigParsing.ts

@@ -151,7 +151,7 @@ namespace ts {
             );
         });
 
-        it("always exclude outDir", () => {
+        it("exclude outDir unless overridden", () => {
             const tsconfigWithoutExclude =
             `{
                 "compilerOptions": {
@@ -169,7 +169,7 @@ namespace ts {
             const allFiles = ["/bin/a.ts", "/b.ts"];
             const expectedFiles = ["/b.ts"];
             assertParseFileList(tsconfigWithoutExclude, "tsconfig.json", rootDir, allFiles, expectedFiles);
-            assertParseFileList(tsconfigWithExclude, "tsconfig.json", rootDir, allFiles, expectedFiles);
+            assertParseFileList(tsconfigWithExclude, "tsconfig.json", rootDir, allFiles, allFiles);
         });
 
         it("implicitly exclude common package folders", () => {

src/harness/unittests/tsserverProjectSystem.ts

@@ -419,22 +419,12 @@ namespace ts.projectSystem {
 
         watchDirectory(directoryName: string, callback: DirectoryWatcherCallback, recursive: boolean): DirectoryWatcher {
             const path = this.toPath(directoryName);
-            const callbacks = this.watchedDirectories[path] || (this.watchedDirectories[path] = []);
-            callbacks.push({ cb: callback, recursive });
+            const cbWithRecursive = { cb: callback, recursive };
+            multiMapAdd(this.watchedDirectories, path, cbWithRecursive);
             return {
                 referenceCount: 0,
                 directoryName,
-                close: () => {
-                    for (let i = 0; i < callbacks.length; i++) {
-                        if (callbacks[i].cb === callback) {
-                            callbacks.splice(i, 1);
-                            break;
-                        }
-                    }
-                    if (!callbacks.length) {
-                        delete this.watchedDirectories[path];
-                    }
-                }
+                close: () => multiMapRemove(this.watchedDirectories, path, cbWithRecursive)
             };
         }
 
@@ -460,17 +450,8 @@ namespace ts.projectSystem {
 
         watchFile(fileName: string, callback: FileWatcherCallback) {
             const path = this.toPath(fileName);
-            const callbacks = this.watchedFiles[path] || (this.watchedFiles[path] = []);
-            callbacks.push(callback);
-            return {
-                close: () => {
-                    const i = callbacks.indexOf(callback);
-                    callbacks.splice(i, 1);
-                    if (!callbacks.length) {
-                        delete this.watchedFiles[path];
-                    }
-                }
-            };
+            multiMapAdd(this.watchedFiles, path, callback);
+            return { close: () => multiMapRemove(this.watchedFiles, path, callback) };
         }
 
         // TOOD: record and invoke callbacks to simulate timer events
@@ -527,7 +508,6 @@ namespace ts.projectSystem {
         readonly resolvePath = (s: string) => s;
         readonly getExecutingFilePath = () => this.executingFilePath;
         readonly getCurrentDirectory = () => this.currentDirectory;
-        readonly writeCompressedData = () => notImplemented();
         readonly write = (s: string) => notImplemented();
         readonly exit = () => notImplemented();
     }

src/harness/virtualFileSystem.ts

@@ -10,9 +10,9 @@ namespace Utils {
             this.name = name;
         }
 
-        isDirectory() { return false; }
-        isFile() { return false; }
-        isFileSystem() { return false; }
+        isDirectory(): this is VirtualDirectory { return false; }
+        isFile(): this is VirtualFile { return false; }
+        isFileSystem(): this is VirtualFileSystem { return false; }
     }
 
     export class VirtualFile extends VirtualFileSystemEntry {
@@ -82,9 +82,8 @@ namespace Utils {
                 return file;
             }
             else if (entry.isFile()) {
-                const file = <VirtualFile>entry;
-                file.content = content;
-                return file;
+                entry.content = content;
+                return entry;
             }
             else {
                 return undefined;
@@ -196,10 +195,18 @@ namespace Utils {
     }
 
     export class MockParseConfigHost extends VirtualFileSystem implements ts.ParseConfigHost {
-        constructor(currentDirectory: string, ignoreCase: boolean, files: string[]) {
+        constructor(currentDirectory: string, ignoreCase: boolean, files: ts.MapLike<string> | string[]) {
             super(currentDirectory, ignoreCase);
-            for (const file of files) {
-                this.addFile(file);
+            const fileNames = (files instanceof Array) ? files : ts.getOwnKeys(files);
+            for (const file of fileNames) {
+                this.addFile(file, new  Harness.LanguageService.ScriptInfo(file, (files as ts.MapLike<string>)[file], /*isRootFile*/false));
+            }
+        }
+
+        readFile(path: string): string {
+            const value = this.traversePath(path);
+            if (value && value.isFile()) {
+                return value.content.content;
             }
         }
 

src/lib/es2015.collection.d.ts

@@ -1,7 +1,7 @@
 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;
@@ -15,6 +15,13 @@ 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> {
     delete(key: K): boolean;
     get(key: K): V | undefined;
@@ -33,7 +40,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;
 }
@@ -45,6 +52,12 @@ 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;
     delete(value: T): boolean;

src/lib/es2015.core.d.ts

@@ -13,15 +13,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
@@ -360,15 +360,15 @@ interface ReadonlyArray<T> {
   find(predicate: (value: T, index: number, obj: ReadonlyArray<T>) => boolean, thisArg?: any): T | undefined;
 
   /**
-    * Returns the index of the first element in the array where predicate is true, and undefined
+    * 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;
 }
 
 interface RegExp {

src/lib/es2015.promise.d.ts

@@ -8,7 +8,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.
@@ -16,20 +16,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.
@@ -37,13 +47,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 {
@@ -140,6 +143,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.

src/lib/es2015.reflect.d.ts

@@ -6,8 +6,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;

src/lib/es5.d.ts

@@ -1060,6 +1060,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.
@@ -1265,13 +1271,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> {
@@ -1531,7 +1568,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,
@@ -1539,7 +1576,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.
@@ -1804,7 +1841,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,
@@ -1812,7 +1849,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.
@@ -2078,7 +2115,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,
@@ -2086,7 +2123,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.
@@ -2351,7 +2388,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,
@@ -2359,7 +2396,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.
@@ -2625,7 +2662,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,
@@ -2633,7 +2670,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.
@@ -2898,7 +2935,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,
@@ -2906,7 +2943,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.
@@ -3171,7 +3208,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,
@@ -3179,7 +3216,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.
@@ -3444,7 +3481,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,
@@ -3452,7 +3489,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.
@@ -3718,7 +3755,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,
@@ -3726,7 +3763,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.
@@ -3943,12 +3980,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 {
@@ -3983,12 +4017,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 {
@@ -4029,88 +4060,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;
 }

src/server/client.ts

@@ -246,6 +246,10 @@ namespace ts.server {
             return response.body[0];
         }
 
+        getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol {
+            throw new Error("Not Implemented Yet.");
+        }
+
         getNavigateToItems(searchValue: string): NavigateToItem[] {
             const args: protocol.NavtoRequestArgs = {
                 searchValue,
@@ -364,6 +368,28 @@ namespace ts.server {
             });
         }
 
+        getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[] {
+            const lineOffset = this.positionToOneBasedLineOffset(fileName, position);
+            const args: protocol.FileLocationRequestArgs = {
+                file: fileName,
+                line: lineOffset.line,
+                offset: lineOffset.offset,
+            };
+
+            const request = this.processRequest<protocol.ImplementationRequest>(CommandNames.Implementation, args);
+            const response = this.processResponse<protocol.ImplementationResponse>(request);
+
+            return response.body.map(entry => {
+                const fileName = entry.file;
+                const start = this.lineOffsetToPosition(fileName, entry.start);
+                const end = this.lineOffsetToPosition(fileName, entry.end);
+                return {
+                    fileName,
+                    textSpan: ts.createTextSpanFromBounds(start, end)
+                };
+            });
+        }
+
         findReferences(fileName: string, position: number): ReferencedSymbol[] {
             // Not yet implemented.
             return [];
@@ -652,6 +678,10 @@ namespace ts.server {
             throw new Error("SourceFile objects are not serializable through the server protocol.");
         }
 
+        getSourceFile(fileName: string): SourceFile {
+            throw new Error("SourceFile objects are not serializable through the server protocol.");
+        }
+
         cleanupSemanticCache(): void {
             throw new Error("cleanupSemanticCache is not available through the server layer.");
         }

src/server/protocol.d.ts

@@ -246,6 +246,14 @@ declare namespace ts.server.protocol {
     export interface TypeDefinitionRequest extends FileLocationRequest {
     }
 
+    /**
+      * Go to implementation request; value of command field is
+      * "implementation". Return response giving the file locations that
+      * implement the symbol found in file at location line, col.
+      */
+    export interface ImplementationRequest extends FileLocationRequest {
+    }
+
     /**
       * Location in source code expressed as (one-based) line and character offset.
       */
@@ -293,6 +301,13 @@ declare namespace ts.server.protocol {
         body?: FileSpan[];
     }
 
+    /**
+      * Implementation response message.  Gives text range for implementations.
+      */
+    export interface ImplementationResponse extends Response {
+        body?: FileSpan[];
+    }
+
     export interface BraceCompletionRequest extends FileLocationRequest {
         arguments: BraceCompletionRequestArgs;
     }
@@ -1343,6 +1358,11 @@ declare namespace ts.server.protocol {
           *  Optional limit on the number of items to return.
           */
         maxResultCount?: number;
+        /**
+          * Optional flag to indicate we want results for just the current file
+          * or the entire project.
+          */
+        currentFileOnly?: boolean;
 
         projectFileName?: string;
     }

src/server/server.ts

@@ -359,7 +359,7 @@ namespace ts.server {
     // average async stat takes about 30 microseconds
     // set chunk size to do 30 files in < 1 millisecond
     function createPollingWatchedFileSet(interval = 2500, chunkSize = 30) {
-        let watchedFiles: WatchedFile[] = [];
+        const watchedFiles: WatchedFile[] = [];
         let nextFileToCheck = 0;
         let watchTimer: any;
 
@@ -422,7 +422,7 @@ namespace ts.server {
         }
 
         function removeFile(file: WatchedFile) {
-            watchedFiles = copyListRemovingItem(file, watchedFiles);
+            unorderedRemoveItem(watchedFiles, file);
         }
 
         return {

src/server/session.ts

@@ -1100,11 +1100,12 @@ namespace ts.server {
         private getNavigateToItems(args: protocol.NavtoRequestArgs, simplifiedResult: boolean): protocol.NavtoItem[] | NavigateToItem[] {
             const projects = this.getProjects(args);
 
+            const fileName = args.currentFileOnly ? args.file && normalizeSlashes(args.file) : undefined
             if (simplifiedResult) {
                 return combineProjectOutput(
                     projects,
                     project => {
-                        const navItems = project.getLanguageService().getNavigateToItems(args.searchValue, args.maxResultCount, /*excludeDts*/ project.isJsOnlyProject());
+                        const navItems = project.getLanguageService().getNavigateToItems(args.searchValue, args.maxResultCount, fileName, /*excludeDts*/ project.isJsOnlyProject());
                         if (!navItems) {
                             return [];
                         }
@@ -1142,7 +1143,7 @@ namespace ts.server {
             else {
                 return combineProjectOutput(
                     projects,
-                    project => project.getLanguageService().getNavigateToItems(args.searchValue, args.maxResultCount, /*excludeDts*/ project.isJsOnlyProject()),
+                    project => project.getLanguageService().getNavigateToItems(args.searchValue, args.maxResultCount, fileName, /*excludeDts*/ project.isJsOnlyProject()),
                     /*comparer*/ undefined,
                     navigateToItemIsEqualTo);
             }

src/server/utilities.ts

@@ -199,6 +199,9 @@ namespace ts.server {
         getProgram: (): any => throwLanguageServiceIsDisabledError(),
         getNonBoundSourceFile: (): any => throwLanguageServiceIsDisabledError(),
         dispose: (): any => throwLanguageServiceIsDisabledError(),
+        getCompletionEntrySymbol: (): any => throwLanguageServiceIsDisabledError(),
+        getImplementationAtPosition: (): any => throwLanguageServiceIsDisabledError(),
+        getSourceFile: (): any => throwLanguageServiceIsDisabledError()
     };
 
     export interface ServerLanguageServiceHost {

src/services/breakpoints.ts

@@ -56,7 +56,7 @@ namespace ts.BreakpointResolver {
             return spanInNode(otherwiseOnNode);
         }
 
-        function spanInNodeArray<T>(nodeArray: NodeArray<T>) {
+        function spanInNodeArray<T extends Node>(nodeArray: NodeArray<T>) {
             return createTextSpanFromBounds(skipTrivia(sourceFile.text, nodeArray.pos), nodeArray.end);
         }
 
@@ -296,7 +296,7 @@ namespace ts.BreakpointResolver {
                             }
                         }
 
-                        if (isExpression(node)) {
+                        if (isPartOfExpression(node)) {
                             switch (node.parent.kind) {
                                 case SyntaxKind.DoStatement:
                                     // Set span as if on while keyword
@@ -395,7 +395,7 @@ namespace ts.BreakpointResolver {
                 // Breakpoint is possible in variableDeclaration only if there is initialization
                 // or its declaration from 'for of'
                 if (variableDeclaration.initializer ||
-                    (variableDeclaration.flags & NodeFlags.Export) ||
+                    hasModifier(variableDeclaration, ModifierFlags.Export) ||
                     variableDeclaration.parent.parent.kind === SyntaxKind.ForOfStatement) {
                     return textSpanFromVariableDeclaration(variableDeclaration);
                 }
@@ -413,7 +413,7 @@ namespace ts.BreakpointResolver {
             function canHaveSpanInParameterDeclaration(parameter: ParameterDeclaration): boolean {
                 // Breakpoint is possible on parameter only if it has initializer, is a rest parameter, or has public or private modifier
                 return !!parameter.initializer || parameter.dotDotDotToken !== undefined ||
-                    !!(parameter.flags & NodeFlags.Public) || !!(parameter.flags & NodeFlags.Private);
+                    hasModifier(parameter, ModifierFlags.Public | ModifierFlags.Private);
             }
 
             function spanInParameterDeclaration(parameter: ParameterDeclaration): TextSpan {
@@ -439,7 +439,7 @@ namespace ts.BreakpointResolver {
             }
 
             function canFunctionHaveSpanInWholeDeclaration(functionDeclaration: FunctionLikeDeclaration) {
-                return !!(functionDeclaration.flags & NodeFlags.Export) ||
+                return hasModifier(functionDeclaration, ModifierFlags.Export) ||
                     (functionDeclaration.parent.kind === SyntaxKind.ClassDeclaration && functionDeclaration.kind !== SyntaxKind.Constructor);
             }
 

src/services/classifier.ts

@@ -0,0 +1,987 @@
+namespace ts {
+    /// Classifier
+    export function createClassifier(): Classifier {
+        const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false);
+
+        /// We do not have a full parser support to know when we should parse a regex or not
+        /// If we consider every slash token to be a regex, we could be missing cases like "1/2/3", where
+        /// we have a series of divide operator. this list allows us to be more accurate by ruling out
+        /// locations where a regexp cannot exist.
+        const noRegexTable: boolean[] = [];
+        noRegexTable[SyntaxKind.Identifier] = true;
+        noRegexTable[SyntaxKind.StringLiteral] = true;
+        noRegexTable[SyntaxKind.NumericLiteral] = true;
+        noRegexTable[SyntaxKind.RegularExpressionLiteral] = true;
+        noRegexTable[SyntaxKind.ThisKeyword] = true;
+        noRegexTable[SyntaxKind.PlusPlusToken] = true;
+        noRegexTable[SyntaxKind.MinusMinusToken] = true;
+        noRegexTable[SyntaxKind.CloseParenToken] = true;
+        noRegexTable[SyntaxKind.CloseBracketToken] = true;
+        noRegexTable[SyntaxKind.CloseBraceToken] = true;
+        noRegexTable[SyntaxKind.TrueKeyword] = true;
+        noRegexTable[SyntaxKind.FalseKeyword] = true;
+
+        // Just a stack of TemplateHeads and OpenCurlyBraces, used to perform rudimentary (inexact)
+        // classification on template strings. Because of the context free nature of templates,
+        // the only precise way to classify a template portion would be by propagating the stack across
+        // lines, just as we do with the end-of-line state. However, this is a burden for implementers,
+        // and the behavior is entirely subsumed by the syntactic classifier anyway, so we instead
+        // flatten any nesting when the template stack is non-empty and encode it in the end-of-line state.
+        // Situations in which this fails are
+        //  1) When template strings are nested across different lines:
+        //          `hello ${ `world
+        //          ` }`
+        //
+        //     Where on the second line, you will get the closing of a template,
+        //     a closing curly, and a new template.
+        //
+        //  2) When substitution expressions have curly braces and the curly brace falls on the next line:
+        //          `hello ${ () => {
+        //          return "world" } } `
+        //
+        //     Where on the second line, you will get the 'return' keyword,
+        //     a string literal, and a template end consisting of '} } `'.
+        const templateStack: SyntaxKind[] = [];
+
+        /** Returns true if 'keyword2' can legally follow 'keyword1' in any language construct. */
+        function canFollow(keyword1: SyntaxKind, keyword2: SyntaxKind) {
+            if (isAccessibilityModifier(keyword1)) {
+                if (keyword2 === SyntaxKind.GetKeyword ||
+                    keyword2 === SyntaxKind.SetKeyword ||
+                    keyword2 === SyntaxKind.ConstructorKeyword ||
+                    keyword2 === SyntaxKind.StaticKeyword) {
+
+                    // Allow things like "public get", "public constructor" and "public static".
+                    // These are all legal.
+                    return true;
+                }
+
+                // Any other keyword following "public" is actually an identifier an not a real
+                // keyword.
+                return false;
+            }
+
+            // Assume any other keyword combination is legal.  This can be refined in the future
+            // if there are more cases we want the classifier to be better at.
+            return true;
+        }
+
+        function convertClassifications(classifications: Classifications, text: string): ClassificationResult {
+            const entries: ClassificationInfo[] = [];
+            const dense = classifications.spans;
+            let lastEnd = 0;
+
+            for (let i = 0, n = dense.length; i < n; i += 3) {
+                const start = dense[i];
+                const length = dense[i + 1];
+                const type = <ClassificationType>dense[i + 2];
+
+                // Make a whitespace entry between the last item and this one.
+                if (lastEnd >= 0) {
+                    const whitespaceLength = start - lastEnd;
+                    if (whitespaceLength > 0) {
+                        entries.push({ length: whitespaceLength, classification: TokenClass.Whitespace });
+                    }
+                }
+
+                entries.push({ length, classification: convertClassification(type) });
+                lastEnd = start + length;
+            }
+
+            const whitespaceLength = text.length - lastEnd;
+            if (whitespaceLength > 0) {
+                entries.push({ length: whitespaceLength, classification: TokenClass.Whitespace });
+            }
+
+            return { entries, finalLexState: classifications.endOfLineState };
+        }
+
+        function convertClassification(type: ClassificationType): TokenClass {
+            switch (type) {
+                case ClassificationType.comment: return TokenClass.Comment;
+                case ClassificationType.keyword: return TokenClass.Keyword;
+                case ClassificationType.numericLiteral: return TokenClass.NumberLiteral;
+                case ClassificationType.operator: return TokenClass.Operator;
+                case ClassificationType.stringLiteral: return TokenClass.StringLiteral;
+                case ClassificationType.whiteSpace: return TokenClass.Whitespace;
+                case ClassificationType.punctuation: return TokenClass.Punctuation;
+                case ClassificationType.identifier:
+                case ClassificationType.className:
+                case ClassificationType.enumName:
+                case ClassificationType.interfaceName:
+                case ClassificationType.moduleName:
+                case ClassificationType.typeParameterName:
+                case ClassificationType.typeAliasName:
+                case ClassificationType.text:
+                case ClassificationType.parameterName:
+                default:
+                    return TokenClass.Identifier;
+            }
+        }
+
+        function getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult {
+            return convertClassifications(getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent), text);
+        }
+
+        // If there is a syntactic classifier ('syntacticClassifierAbsent' is false),
+        // we will be more conservative in order to avoid conflicting with the syntactic classifier.
+        function getEncodedLexicalClassifications(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications {
+            let offset = 0;
+            let token = SyntaxKind.Unknown;
+            let lastNonTriviaToken = SyntaxKind.Unknown;
+
+            // Empty out the template stack for reuse.
+            while (templateStack.length > 0) {
+                templateStack.pop();
+            }
+
+            // If we're in a string literal, then prepend: "\
+            // (and a newline).  That way when we lex we'll think we're still in a string literal.
+            //
+            // If we're in a multiline comment, then prepend: /*
+            // (and a newline).  That way when we lex we'll think we're still in a multiline comment.
+            switch (lexState) {
+                case EndOfLineState.InDoubleQuoteStringLiteral:
+                    text = "\"\\\n" + text;
+                    offset = 3;
+                    break;
+                case EndOfLineState.InSingleQuoteStringLiteral:
+                    text = "'\\\n" + text;
+                    offset = 3;
+                    break;
+                case EndOfLineState.InMultiLineCommentTrivia:
+                    text = "/*\n" + text;
+                    offset = 3;
+                    break;
+                case EndOfLineState.InTemplateHeadOrNoSubstitutionTemplate:
+                    text = "`\n" + text;
+                    offset = 2;
+                    break;
+                case EndOfLineState.InTemplateMiddleOrTail:
+                    text = "}\n" + text;
+                    offset = 2;
+                // fallthrough
+                case EndOfLineState.InTemplateSubstitutionPosition:
+                    templateStack.push(SyntaxKind.TemplateHead);
+                    break;
+            }
+
+            scanner.setText(text);
+
+            const result: Classifications = {
+                endOfLineState: EndOfLineState.None,
+                spans: []
+            };
+
+            // We can run into an unfortunate interaction between the lexical and syntactic classifier
+            // when the user is typing something generic.  Consider the case where the user types:
+            //
+            //      Foo<number
+            //
+            // From the lexical classifier's perspective, 'number' is a keyword, and so the word will
+            // be classified as such.  However, from the syntactic classifier's tree-based perspective
+            // this is simply an expression with the identifier 'number' on the RHS of the less than
+            // token.  So the classification will go back to being an identifier.  The moment the user
+            // types again, number will become a keyword, then an identifier, etc. etc.
+            //
+            // To try to avoid this problem, we avoid classifying contextual keywords as keywords
+            // when the user is potentially typing something generic.  We just can't do a good enough
+            // job at the lexical level, and so well leave it up to the syntactic classifier to make
+            // the determination.
+            //
+            // In order to determine if the user is potentially typing something generic, we use a
+            // weak heuristic where we track < and > tokens.  It's a weak heuristic, but should
+            // work well enough in practice.
+            let angleBracketStack = 0;
+
+            do {
+                token = scanner.scan();
+
+                if (!isTrivia(token)) {
+                    if ((token === SyntaxKind.SlashToken || token === SyntaxKind.SlashEqualsToken) && !noRegexTable[lastNonTriviaToken]) {
+                        if (scanner.reScanSlashToken() === SyntaxKind.RegularExpressionLiteral) {
+                            token = SyntaxKind.RegularExpressionLiteral;
+                        }
+                    }
+                    else if (lastNonTriviaToken === SyntaxKind.DotToken && isKeyword(token)) {
+                        token = SyntaxKind.Identifier;
+                    }
+                    else if (isKeyword(lastNonTriviaToken) && isKeyword(token) && !canFollow(lastNonTriviaToken, token)) {
+                        // We have two keywords in a row.  Only treat the second as a keyword if
+                        // it's a sequence that could legally occur in the language.  Otherwise
+                        // treat it as an identifier.  This way, if someone writes "private var"
+                        // we recognize that 'var' is actually an identifier here.
+                        token = SyntaxKind.Identifier;
+                    }
+                    else if (lastNonTriviaToken === SyntaxKind.Identifier &&
+                        token === SyntaxKind.LessThanToken) {
+                        // Could be the start of something generic.  Keep track of that by bumping
+                        // up the current count of generic contexts we may be in.
+                        angleBracketStack++;
+                    }
+                    else if (token === SyntaxKind.GreaterThanToken && angleBracketStack > 0) {
+                        // If we think we're currently in something generic, then mark that that
+                        // generic entity is complete.
+                        angleBracketStack--;
+                    }
+                    else if (token === SyntaxKind.AnyKeyword ||
+                        token === SyntaxKind.StringKeyword ||
+                        token === SyntaxKind.NumberKeyword ||
+                        token === SyntaxKind.BooleanKeyword ||
+                        token === SyntaxKind.SymbolKeyword) {
+                        if (angleBracketStack > 0 && !syntacticClassifierAbsent) {
+                            // If it looks like we're could be in something generic, don't classify this
+                            // as a keyword.  We may just get overwritten by the syntactic classifier,
+                            // causing a noisy experience for the user.
+                            token = SyntaxKind.Identifier;
+                        }
+                    }
+                    else if (token === SyntaxKind.TemplateHead) {
+                        templateStack.push(token);
+                    }
+                    else if (token === SyntaxKind.OpenBraceToken) {
+                        // If we don't have anything on the template stack,
+                        // then we aren't trying to keep track of a previously scanned template head.
+                        if (templateStack.length > 0) {
+                            templateStack.push(token);
+                        }
+                    }
+                    else if (token === SyntaxKind.CloseBraceToken) {
+                        // If we don't have anything on the template stack,
+                        // then we aren't trying to keep track of a previously scanned template head.
+                        if (templateStack.length > 0) {
+                            const lastTemplateStackToken = lastOrUndefined(templateStack);
+
+                            if (lastTemplateStackToken === SyntaxKind.TemplateHead) {
+                                token = scanner.reScanTemplateToken();
+
+                                // Only pop on a TemplateTail; a TemplateMiddle indicates there is more for us.
+                                if (token === SyntaxKind.TemplateTail) {
+                                    templateStack.pop();
+                                }
+                                else {
+                                    Debug.assert(token === SyntaxKind.TemplateMiddle, "Should have been a template middle. Was " + token);
+                                }
+                            }
+                            else {
+                                Debug.assert(lastTemplateStackToken === SyntaxKind.OpenBraceToken, "Should have been an open brace. Was: " + token);
+                                templateStack.pop();
+                            }
+                        }
+                    }
+
+                    lastNonTriviaToken = token;
+                }
+
+                processToken();
+            }
+            while (token !== SyntaxKind.EndOfFileToken);
+
+            return result;
+
+            function processToken(): void {
+                const start = scanner.getTokenPos();
+                const end = scanner.getTextPos();
+
+                addResult(start, end, classFromKind(token));
+
+                if (end >= text.length) {
+                    if (token === SyntaxKind.StringLiteral) {
+                        // Check to see if we finished up on a multiline string literal.
+                        const tokenText = scanner.getTokenText();
+                        if (scanner.isUnterminated()) {
+                            const lastCharIndex = tokenText.length - 1;
+
+                            let numBackslashes = 0;
+                            while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === CharacterCodes.backslash) {
+                                numBackslashes++;
+                            }
+
+                            // If we have an odd number of backslashes, then the multiline string is unclosed
+                            if (numBackslashes & 1) {
+                                const quoteChar = tokenText.charCodeAt(0);
+                                result.endOfLineState = quoteChar === CharacterCodes.doubleQuote
+                                    ? EndOfLineState.InDoubleQuoteStringLiteral
+                                    : EndOfLineState.InSingleQuoteStringLiteral;
+                            }
+                        }
+                    }
+                    else if (token === SyntaxKind.MultiLineCommentTrivia) {
+                        // Check to see if the multiline comment was unclosed.
+                        if (scanner.isUnterminated()) {
+                            result.endOfLineState = EndOfLineState.InMultiLineCommentTrivia;
+                        }
+                    }
+                    else if (isTemplateLiteralKind(token)) {
+                        if (scanner.isUnterminated()) {
+                            if (token === SyntaxKind.TemplateTail) {
+                                result.endOfLineState = EndOfLineState.InTemplateMiddleOrTail;
+                            }
+                            else if (token === SyntaxKind.NoSubstitutionTemplateLiteral) {
+                                result.endOfLineState = EndOfLineState.InTemplateHeadOrNoSubstitutionTemplate;
+                            }
+                            else {
+                                Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token);
+                            }
+                        }
+                    }
+                    else if (templateStack.length > 0 && lastOrUndefined(templateStack) === SyntaxKind.TemplateHead) {
+                        result.endOfLineState = EndOfLineState.InTemplateSubstitutionPosition;
+                    }
+                }
+            }
+
+            function addResult(start: number, end: number, classification: ClassificationType): void {
+                if (classification === ClassificationType.whiteSpace) {
+                    // Don't bother with whitespace classifications.  They're not needed.
+                    return;
+                }
+
+                if (start === 0 && offset > 0) {
+                    // We're classifying the first token, and this was a case where we prepended
+                    // text.  We should consider the start of this token to be at the start of
+                    // the original text.
+                    start += offset;
+                }
+
+                // All our tokens are in relation to the augmented text.  Move them back to be
+                // relative to the original text.
+                start -= offset;
+                end -= offset;
+                const length = end - start;
+
+                if (length > 0) {
+                    result.spans.push(start);
+                    result.spans.push(length);
+                    result.spans.push(classification);
+                }
+            }
+        }
+
+        function isBinaryExpressionOperatorToken(token: SyntaxKind): boolean {
+            switch (token) {
+                case SyntaxKind.AsteriskToken:
+                case SyntaxKind.SlashToken:
+                case SyntaxKind.PercentToken:
+                case SyntaxKind.PlusToken:
+                case SyntaxKind.MinusToken:
+                case SyntaxKind.LessThanLessThanToken:
+                case SyntaxKind.GreaterThanGreaterThanToken:
+                case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                case SyntaxKind.LessThanToken:
+                case SyntaxKind.GreaterThanToken:
+                case SyntaxKind.LessThanEqualsToken:
+                case SyntaxKind.GreaterThanEqualsToken:
+                case SyntaxKind.InstanceOfKeyword:
+                case SyntaxKind.InKeyword:
+                case SyntaxKind.AsKeyword:
+                case SyntaxKind.EqualsEqualsToken:
+                case SyntaxKind.ExclamationEqualsToken:
+                case SyntaxKind.EqualsEqualsEqualsToken:
+                case SyntaxKind.ExclamationEqualsEqualsToken:
+                case SyntaxKind.AmpersandToken:
+                case SyntaxKind.CaretToken:
+                case SyntaxKind.BarToken:
+                case SyntaxKind.AmpersandAmpersandToken:
+                case SyntaxKind.BarBarToken:
+                case SyntaxKind.BarEqualsToken:
+                case SyntaxKind.AmpersandEqualsToken:
+                case SyntaxKind.CaretEqualsToken:
+                case SyntaxKind.LessThanLessThanEqualsToken:
+                case SyntaxKind.GreaterThanGreaterThanEqualsToken:
+                case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+                case SyntaxKind.PlusEqualsToken:
+                case SyntaxKind.MinusEqualsToken:
+                case SyntaxKind.AsteriskEqualsToken:
+                case SyntaxKind.SlashEqualsToken:
+                case SyntaxKind.PercentEqualsToken:
+                case SyntaxKind.EqualsToken:
+                case SyntaxKind.CommaToken:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        function isPrefixUnaryExpressionOperatorToken(token: SyntaxKind): boolean {
+            switch (token) {
+                case SyntaxKind.PlusToken:
+                case SyntaxKind.MinusToken:
+                case SyntaxKind.TildeToken:
+                case SyntaxKind.ExclamationToken:
+                case SyntaxKind.PlusPlusToken:
+                case SyntaxKind.MinusMinusToken:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        function isKeyword(token: SyntaxKind): boolean {
+            return token >= SyntaxKind.FirstKeyword && token <= SyntaxKind.LastKeyword;
+        }
+
+        function classFromKind(token: SyntaxKind): ClassificationType {
+            if (isKeyword(token)) {
+                return ClassificationType.keyword;
+            }
+            else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) {
+                return ClassificationType.operator;
+            }
+            else if (token >= SyntaxKind.FirstPunctuation && token <= SyntaxKind.LastPunctuation) {
+                return ClassificationType.punctuation;
+            }
+
+            switch (token) {
+                case SyntaxKind.NumericLiteral:
+                    return ClassificationType.numericLiteral;
+                case SyntaxKind.StringLiteral:
+                    return ClassificationType.stringLiteral;
+                case SyntaxKind.RegularExpressionLiteral:
+                    return ClassificationType.regularExpressionLiteral;
+                case SyntaxKind.ConflictMarkerTrivia:
+                case SyntaxKind.MultiLineCommentTrivia:
+                case SyntaxKind.SingleLineCommentTrivia:
+                    return ClassificationType.comment;
+                case SyntaxKind.WhitespaceTrivia:
+                case SyntaxKind.NewLineTrivia:
+                    return ClassificationType.whiteSpace;
+                case SyntaxKind.Identifier:
+                default:
+                    if (isTemplateLiteralKind(token)) {
+                        return ClassificationType.stringLiteral;
+                    }
+                    return ClassificationType.identifier;
+            }
+        }
+
+        return {
+            getClassificationsForLine,
+            getEncodedLexicalClassifications
+        };
+    }
+
+    /* @internal */
+    export function getSemanticClassifications(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, classifiableNames: Map<string>, span: TextSpan): ClassifiedSpan[] {
+        return convertClassifications(getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span));
+    }
+
+    function checkForClassificationCancellation(cancellationToken: CancellationToken, kind: SyntaxKind) {
+        // We don't want to actually call back into our host on every node to find out if we've
+        // been canceled.  That would be an enormous amount of chattyness, along with the all
+        // the overhead of marshalling the data to/from the host.  So instead we pick a few
+        // reasonable node kinds to bother checking on.  These node kinds represent high level
+        // constructs that we would expect to see commonly, but just at a far less frequent
+        // interval.
+        //
+        // For example, in checker.ts (around 750k) we only have around 600 of these constructs.
+        // That means we're calling back into the host around every 1.2k of the file we process.
+        // Lib.d.ts has similar numbers.
+        switch (kind) {
+            case SyntaxKind.ModuleDeclaration:
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.FunctionDeclaration:
+                cancellationToken.throwIfCancellationRequested();
+        }
+    }
+
+    /* @internal */
+    export function getEncodedSemanticClassifications(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, classifiableNames: Map<string>, span: TextSpan): Classifications {
+        const result: number[] = [];
+        processNode(sourceFile);
+
+        return { spans: result, endOfLineState: EndOfLineState.None };
+
+        function pushClassification(start: number, length: number, type: ClassificationType) {
+            result.push(start);
+            result.push(length);
+            result.push(type);
+        }
+
+        function classifySymbol(symbol: Symbol, meaningAtPosition: SemanticMeaning): ClassificationType {
+            const flags = symbol.getFlags();
+            if ((flags & SymbolFlags.Classifiable) === SymbolFlags.None) {
+                return;
+            }
+
+            if (flags & SymbolFlags.Class) {
+                return ClassificationType.className;
+            }
+            else if (flags & SymbolFlags.Enum) {
+                return ClassificationType.enumName;
+            }
+            else if (flags & SymbolFlags.TypeAlias) {
+                return ClassificationType.typeAliasName;
+            }
+            else if (meaningAtPosition & SemanticMeaning.Type) {
+                if (flags & SymbolFlags.Interface) {
+                    return ClassificationType.interfaceName;
+                }
+                else if (flags & SymbolFlags.TypeParameter) {
+                    return ClassificationType.typeParameterName;
+                }
+            }
+            else if (flags & SymbolFlags.Module) {
+                // Only classify a module as such if
+                //  - It appears in a namespace context.
+                //  - There exists a module declaration which actually impacts the value side.
+                if (meaningAtPosition & SemanticMeaning.Namespace ||
+                    (meaningAtPosition & SemanticMeaning.Value && hasValueSideModule(symbol))) {
+                    return ClassificationType.moduleName;
+                }
+            }
+
+            return undefined;
+
+            /**
+             * Returns true if there exists a module that introduces entities on the value side.
+             */
+            function hasValueSideModule(symbol: Symbol): boolean {
+                return forEach(symbol.declarations, declaration => {
+                    return declaration.kind === SyntaxKind.ModuleDeclaration &&
+                        getModuleInstanceState(declaration) === ModuleInstanceState.Instantiated;
+                });
+            }
+        }
+
+        function processNode(node: Node) {
+            // Only walk into nodes that intersect the requested span.
+            if (node && textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) {
+                const kind = node.kind;
+                checkForClassificationCancellation(cancellationToken, kind);
+
+                if (kind === SyntaxKind.Identifier && !nodeIsMissing(node)) {
+                    const identifier = <Identifier>node;
+
+                    // Only bother calling into the typechecker if this is an identifier that
+                    // could possibly resolve to a type name.  This makes classification run
+                    // in a third of the time it would normally take.
+                    if (classifiableNames[identifier.text]) {
+                        const symbol = typeChecker.getSymbolAtLocation(node);
+                        if (symbol) {
+                            const type = classifySymbol(symbol, getMeaningFromLocation(node));
+                            if (type) {
+                                pushClassification(node.getStart(), node.getWidth(), type);
+                            }
+                        }
+                    }
+                }
+
+                forEachChild(node, processNode);
+            }
+        }
+    }
+
+    function getClassificationTypeName(type: ClassificationType) {
+        switch (type) {
+            case ClassificationType.comment: return ClassificationTypeNames.comment;
+            case ClassificationType.identifier: return ClassificationTypeNames.identifier;
+            case ClassificationType.keyword: return ClassificationTypeNames.keyword;
+            case ClassificationType.numericLiteral: return ClassificationTypeNames.numericLiteral;
+            case ClassificationType.operator: return ClassificationTypeNames.operator;
+            case ClassificationType.stringLiteral: return ClassificationTypeNames.stringLiteral;
+            case ClassificationType.whiteSpace: return ClassificationTypeNames.whiteSpace;
+            case ClassificationType.text: return ClassificationTypeNames.text;
+            case ClassificationType.punctuation: return ClassificationTypeNames.punctuation;
+            case ClassificationType.className: return ClassificationTypeNames.className;
+            case ClassificationType.enumName: return ClassificationTypeNames.enumName;
+            case ClassificationType.interfaceName: return ClassificationTypeNames.interfaceName;
+            case ClassificationType.moduleName: return ClassificationTypeNames.moduleName;
+            case ClassificationType.typeParameterName: return ClassificationTypeNames.typeParameterName;
+            case ClassificationType.typeAliasName: return ClassificationTypeNames.typeAliasName;
+            case ClassificationType.parameterName: return ClassificationTypeNames.parameterName;
+            case ClassificationType.docCommentTagName: return ClassificationTypeNames.docCommentTagName;
+            case ClassificationType.jsxOpenTagName: return ClassificationTypeNames.jsxOpenTagName;
+            case ClassificationType.jsxCloseTagName: return ClassificationTypeNames.jsxCloseTagName;
+            case ClassificationType.jsxSelfClosingTagName: return ClassificationTypeNames.jsxSelfClosingTagName;
+            case ClassificationType.jsxAttribute: return ClassificationTypeNames.jsxAttribute;
+            case ClassificationType.jsxText: return ClassificationTypeNames.jsxText;
+            case ClassificationType.jsxAttributeStringLiteralValue: return ClassificationTypeNames.jsxAttributeStringLiteralValue;
+        }
+    }
+
+    function convertClassifications(classifications: Classifications): ClassifiedSpan[] {
+        Debug.assert(classifications.spans.length % 3 === 0);
+        const dense = classifications.spans;
+        const result: ClassifiedSpan[] = [];
+        for (let i = 0, n = dense.length; i < n; i += 3) {
+            result.push({
+                textSpan: createTextSpan(dense[i], dense[i + 1]),
+                classificationType: getClassificationTypeName(dense[i + 2])
+            });
+        }
+
+        return result;
+    }
+
+    /* @internal */
+    export function getSyntacticClassifications(cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): ClassifiedSpan[] {
+        return convertClassifications(getEncodedSyntacticClassifications(cancellationToken, sourceFile, span));
+    }
+
+    /* @internal */
+    export function getEncodedSyntacticClassifications(cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): Classifications {
+        const spanStart = span.start;
+        const spanLength = span.length;
+
+        // Make a scanner we can get trivia from.
+        const triviaScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+        const mergeConflictScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+
+        const result: number[] = [];
+        processElement(sourceFile);
+
+        return { spans: result, endOfLineState: EndOfLineState.None };
+
+        function pushClassification(start: number, length: number, type: ClassificationType) {
+            result.push(start);
+            result.push(length);
+            result.push(type);
+        }
+
+        function classifyLeadingTriviaAndGetTokenStart(token: Node): number {
+            triviaScanner.setTextPos(token.pos);
+            while (true) {
+                const start = triviaScanner.getTextPos();
+                // only bother scanning if we have something that could be trivia.
+                if (!couldStartTrivia(sourceFile.text, start)) {
+                    return start;
+                }
+
+                const kind = triviaScanner.scan();
+                const end = triviaScanner.getTextPos();
+                const width = end - start;
+
+                // The moment we get something that isn't trivia, then stop processing.
+                if (!isTrivia(kind)) {
+                    return start;
+                }
+
+                // Don't bother with newlines/whitespace.
+                if (kind === SyntaxKind.NewLineTrivia || kind === SyntaxKind.WhitespaceTrivia) {
+                    continue;
+                }
+
+                // Only bother with the trivia if it at least intersects the span of interest.
+                if (isComment(kind)) {
+                    classifyComment(token, kind, start, width);
+
+                    // Classifying a comment might cause us to reuse the trivia scanner
+                    // (because of jsdoc comments).  So after we classify the comment make
+                    // sure we set the scanner position back to where it needs to be.
+                    triviaScanner.setTextPos(end);
+                    continue;
+                }
+
+                if (kind === SyntaxKind.ConflictMarkerTrivia) {
+                    const text = sourceFile.text;
+                    const ch = text.charCodeAt(start);
+
+                    // for the <<<<<<< and >>>>>>> markers, we just add them in as comments
+                    // in the classification stream.
+                    if (ch === CharacterCodes.lessThan || ch === CharacterCodes.greaterThan) {
+                        pushClassification(start, width, ClassificationType.comment);
+                        continue;
+                    }
+
+                    // for the ======== add a comment for the first line, and then lex all
+                    // subsequent lines up until the end of the conflict marker.
+                    Debug.assert(ch === CharacterCodes.equals);
+                    classifyDisabledMergeCode(text, start, end);
+                }
+            }
+        }
+
+        function classifyComment(token: Node, kind: SyntaxKind, start: number, width: number) {
+            if (kind === SyntaxKind.MultiLineCommentTrivia) {
+                // See if this is a doc comment.  If so, we'll classify certain portions of it
+                // specially.
+                const docCommentAndDiagnostics = parseIsolatedJSDocComment(sourceFile.text, start, width);
+                if (docCommentAndDiagnostics && docCommentAndDiagnostics.jsDoc) {
+                    docCommentAndDiagnostics.jsDoc.parent = token;
+                    classifyJSDocComment(docCommentAndDiagnostics.jsDoc);
+                    return;
+                }
+            }
+
+            // Simple comment.  Just add as is.
+            pushCommentRange(start, width);
+        }
+
+        function pushCommentRange(start: number, width: number) {
+            pushClassification(start, width, ClassificationType.comment);
+        }
+
+        function classifyJSDocComment(docComment: JSDoc) {
+            let pos = docComment.pos;
+
+            if (docComment.tags) {
+                for (const tag of docComment.tags) {
+                    // As we walk through each tag, classify the portion of text from the end of
+                    // the last tag (or the start of the entire doc comment) as 'comment'.
+                    if (tag.pos !== pos) {
+                        pushCommentRange(pos, tag.pos - pos);
+                    }
+
+                    pushClassification(tag.atToken.pos, tag.atToken.end - tag.atToken.pos, ClassificationType.punctuation);
+                    pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, ClassificationType.docCommentTagName);
+
+                    pos = tag.tagName.end;
+
+                    switch (tag.kind) {
+                        case SyntaxKind.JSDocParameterTag:
+                            processJSDocParameterTag(<JSDocParameterTag>tag);
+                            break;
+                        case SyntaxKind.JSDocTemplateTag:
+                            processJSDocTemplateTag(<JSDocTemplateTag>tag);
+                            break;
+                        case SyntaxKind.JSDocTypeTag:
+                            processElement((<JSDocTypeTag>tag).typeExpression);
+                            break;
+                        case SyntaxKind.JSDocReturnTag:
+                            processElement((<JSDocReturnTag>tag).typeExpression);
+                            break;
+                    }
+
+                    pos = tag.end;
+                }
+            }
+
+            if (pos !== docComment.end) {
+                pushCommentRange(pos, docComment.end - pos);
+            }
+
+            return;
+
+            function processJSDocParameterTag(tag: JSDocParameterTag) {
+                if (tag.preParameterName) {
+                    pushCommentRange(pos, tag.preParameterName.pos - pos);
+                    pushClassification(tag.preParameterName.pos, tag.preParameterName.end - tag.preParameterName.pos, ClassificationType.parameterName);
+                    pos = tag.preParameterName.end;
+                }
+
+                if (tag.typeExpression) {
+                    pushCommentRange(pos, tag.typeExpression.pos - pos);
+                    processElement(tag.typeExpression);
+                    pos = tag.typeExpression.end;
+                }
+
+                if (tag.postParameterName) {
+                    pushCommentRange(pos, tag.postParameterName.pos - pos);
+                    pushClassification(tag.postParameterName.pos, tag.postParameterName.end - tag.postParameterName.pos, ClassificationType.parameterName);
+                    pos = tag.postParameterName.end;
+                }
+            }
+        }
+
+        function processJSDocTemplateTag(tag: JSDocTemplateTag) {
+            for (const child of tag.getChildren()) {
+                processElement(child);
+            }
+        }
+
+        function classifyDisabledMergeCode(text: string, start: number, end: number) {
+            // Classify the line that the ======= marker is on as a comment.  Then just lex
+            // all further tokens and add them to the result.
+            let i: number;
+            for (i = start; i < end; i++) {
+                if (isLineBreak(text.charCodeAt(i))) {
+                    break;
+                }
+            }
+            pushClassification(start, i - start, ClassificationType.comment);
+            mergeConflictScanner.setTextPos(i);
+
+            while (mergeConflictScanner.getTextPos() < end) {
+                classifyDisabledCodeToken();
+            }
+        }
+
+        function classifyDisabledCodeToken() {
+            const start = mergeConflictScanner.getTextPos();
+            const tokenKind = mergeConflictScanner.scan();
+            const end = mergeConflictScanner.getTextPos();
+
+            const type = classifyTokenType(tokenKind);
+            if (type) {
+                pushClassification(start, end - start, type);
+            }
+        }
+
+        /**
+         * Returns true if node should be treated as classified and no further processing is required.
+         * False will mean that node is not classified and traverse routine should recurse into node contents.
+         */
+        function tryClassifyNode(node: Node): boolean {
+            if (isJSDocTag(node)) {
+                return true;
+            }
+
+            if (nodeIsMissing(node)) {
+                return true;
+            }
+
+            const classifiedElementName = tryClassifyJsxElementName(node);
+            if (!isToken(node) && node.kind !== SyntaxKind.JsxText && classifiedElementName === undefined) {
+                return false;
+            }
+
+            const tokenStart = node.kind === SyntaxKind.JsxText ? node.pos : classifyLeadingTriviaAndGetTokenStart(node);
+
+            const tokenWidth = node.end - tokenStart;
+            Debug.assert(tokenWidth >= 0);
+            if (tokenWidth > 0) {
+                const type = classifiedElementName || classifyTokenType(node.kind, node);
+                if (type) {
+                    pushClassification(tokenStart, tokenWidth, type);
+                }
+            }
+
+            return true;
+        }
+
+        function tryClassifyJsxElementName(token: Node): ClassificationType {
+            switch (token.parent && token.parent.kind) {
+                case SyntaxKind.JsxOpeningElement:
+                    if ((<JsxOpeningElement>token.parent).tagName === token) {
+                        return ClassificationType.jsxOpenTagName;
+                    }
+                    break;
+                case SyntaxKind.JsxClosingElement:
+                    if ((<JsxClosingElement>token.parent).tagName === token) {
+                        return ClassificationType.jsxCloseTagName;
+                    }
+                    break;
+                case SyntaxKind.JsxSelfClosingElement:
+                    if ((<JsxSelfClosingElement>token.parent).tagName === token) {
+                        return ClassificationType.jsxSelfClosingTagName;
+                    }
+                    break;
+                case SyntaxKind.JsxAttribute:
+                    if ((<JsxAttribute>token.parent).name === token) {
+                        return ClassificationType.jsxAttribute;
+                    }
+                    break;
+            }
+            return undefined;
+        }
+
+        // for accurate classification, the actual token should be passed in.  however, for
+        // cases like 'disabled merge code' classification, we just get the token kind and
+        // classify based on that instead.
+        function classifyTokenType(tokenKind: SyntaxKind, token?: Node): ClassificationType {
+            if (isKeyword(tokenKind)) {
+                return ClassificationType.keyword;
+            }
+
+            // Special case < and >  If they appear in a generic context they are punctuation,
+            // not operators.
+            if (tokenKind === SyntaxKind.LessThanToken || tokenKind === SyntaxKind.GreaterThanToken) {
+                // If the node owning the token has a type argument list or type parameter list, then
+                // we can effectively assume that a '<' and '>' belong to those lists.
+                if (token && getTypeArgumentOrTypeParameterList(token.parent)) {
+                    return ClassificationType.punctuation;
+                }
+            }
+
+            if (isPunctuation(tokenKind)) {
+                if (token) {
+                    if (tokenKind === SyntaxKind.EqualsToken) {
+                        // the '=' in a variable declaration is special cased here.
+                        if (token.parent.kind === SyntaxKind.VariableDeclaration ||
+                            token.parent.kind === SyntaxKind.PropertyDeclaration ||
+                            token.parent.kind === SyntaxKind.Parameter ||
+                            token.parent.kind === SyntaxKind.JsxAttribute) {
+                            return ClassificationType.operator;
+                        }
+                    }
+
+                    if (token.parent.kind === SyntaxKind.BinaryExpression ||
+                        token.parent.kind === SyntaxKind.PrefixUnaryExpression ||
+                        token.parent.kind === SyntaxKind.PostfixUnaryExpression ||
+                        token.parent.kind === SyntaxKind.ConditionalExpression) {
+                        return ClassificationType.operator;
+                    }
+                }
+
+                return ClassificationType.punctuation;
+            }
+            else if (tokenKind === SyntaxKind.NumericLiteral) {
+                return ClassificationType.numericLiteral;
+            }
+            else if (tokenKind === SyntaxKind.StringLiteral) {
+                return token.parent.kind === SyntaxKind.JsxAttribute ? ClassificationType.jsxAttributeStringLiteralValue : ClassificationType.stringLiteral;
+            }
+            else if (tokenKind === SyntaxKind.RegularExpressionLiteral) {
+                // TODO: we should get another classification type for these literals.
+                return ClassificationType.stringLiteral;
+            }
+            else if (isTemplateLiteralKind(tokenKind)) {
+                // TODO (drosen): we should *also* get another classification type for these literals.
+                return ClassificationType.stringLiteral;
+            }
+            else if (tokenKind === SyntaxKind.JsxText) {
+                return ClassificationType.jsxText;
+            }
+            else if (tokenKind === SyntaxKind.Identifier) {
+                if (token) {
+                    switch (token.parent.kind) {
+                        case SyntaxKind.ClassDeclaration:
+                            if ((<ClassDeclaration>token.parent).name === token) {
+                                return ClassificationType.className;
+                            }
+                            return;
+                        case SyntaxKind.TypeParameter:
+                            if ((<TypeParameterDeclaration>token.parent).name === token) {
+                                return ClassificationType.typeParameterName;
+                            }
+                            return;
+                        case SyntaxKind.InterfaceDeclaration:
+                            if ((<InterfaceDeclaration>token.parent).name === token) {
+                                return ClassificationType.interfaceName;
+                            }
+                            return;
+                        case SyntaxKind.EnumDeclaration:
+                            if ((<EnumDeclaration>token.parent).name === token) {
+                                return ClassificationType.enumName;
+                            }
+                            return;
+                        case SyntaxKind.ModuleDeclaration:
+                            if ((<ModuleDeclaration>token.parent).name === token) {
+                                return ClassificationType.moduleName;
+                            }
+                            return;
+                        case SyntaxKind.Parameter:
+                            if ((<ParameterDeclaration>token.parent).name === token) {
+                                const isThis = token.kind === SyntaxKind.Identifier && (<Identifier>token).originalKeywordKind === SyntaxKind.ThisKeyword;
+                                return isThis ? ClassificationType.keyword : ClassificationType.parameterName;
+                            }
+                            return;
+                    }
+                }
+                return ClassificationType.identifier;
+            }
+        }
+
+        function processElement(element: Node) {
+            if (!element) {
+                return;
+            }
+
+            // Ignore nodes that don't intersect the original span to classify.
+            if (decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) {
+                checkForClassificationCancellation(cancellationToken, element.kind);
+
+                const children = element.getChildren(sourceFile);
+                for (let i = 0, n = children.length; i < n; i++) {
+                    const child = children[i];
+                    if (!tryClassifyNode(child)) {
+                        // Recurse into our child nodes.
+                        processElement(child);
+                    }
+                }
+            }
+        }
+    }
+}

src/services/documentHighlights.ts

@@ -0,0 +1,638 @@
+/* @internal */
+namespace ts.DocumentHighlights {
+    export function getDocumentHighlights(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, position: number, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
+        const node = getTouchingWord(sourceFile, position);
+        if (!node) {
+            return undefined;
+        }
+
+        return getSemanticDocumentHighlights(node) || getSyntacticDocumentHighlights(node);
+
+        function getHighlightSpanForNode(node: Node): HighlightSpan {
+            const start = node.getStart();
+            const end = node.getEnd();
+
+            return {
+                fileName: sourceFile.fileName,
+                textSpan: createTextSpanFromBounds(start, end),
+                kind: HighlightSpanKind.none
+            };
+        }
+
+        function getSemanticDocumentHighlights(node: Node): DocumentHighlights[] {
+            if (node.kind === SyntaxKind.Identifier ||
+                node.kind === SyntaxKind.ThisKeyword ||
+                node.kind === SyntaxKind.ThisType ||
+                node.kind === SyntaxKind.SuperKeyword ||
+                node.kind === SyntaxKind.StringLiteral ||
+                isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
+
+                const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/ false, /*findInComments*/ false, /*implementations*/false);
+                return convertReferencedSymbols(referencedSymbols);
+
+            }
+
+            return undefined;
+
+            function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
+                if (!referencedSymbols) {
+                    return undefined;
+                }
+
+                const fileNameToDocumentHighlights = createMap<DocumentHighlights>();
+                const result: DocumentHighlights[] = [];
+                for (const referencedSymbol of referencedSymbols) {
+                    for (const referenceEntry of referencedSymbol.references) {
+                        const fileName = referenceEntry.fileName;
+                        let documentHighlights = fileNameToDocumentHighlights[fileName];
+                        if (!documentHighlights) {
+                            documentHighlights = { fileName, highlightSpans: [] };
+
+                            fileNameToDocumentHighlights[fileName] = documentHighlights;
+                            result.push(documentHighlights);
+                        }
+
+                        documentHighlights.highlightSpans.push({
+                            textSpan: referenceEntry.textSpan,
+                            kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
+                        });
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        function getSyntacticDocumentHighlights(node: Node): DocumentHighlights[] {
+            const fileName = sourceFile.fileName;
+
+            const highlightSpans = getHighlightSpans(node);
+            if (!highlightSpans || highlightSpans.length === 0) {
+                return undefined;
+            }
+
+            return [{ fileName, highlightSpans }];
+
+            // returns true if 'node' is defined and has a matching 'kind'.
+            function hasKind(node: Node, kind: SyntaxKind) {
+                return node !== undefined && node.kind === kind;
+            }
+
+            // Null-propagating 'parent' function.
+            function parent(node: Node): Node {
+                return node && node.parent;
+            }
+
+            function getHighlightSpans(node: Node): HighlightSpan[] {
+                if (node) {
+                    switch (node.kind) {
+                        case SyntaxKind.IfKeyword:
+                        case SyntaxKind.ElseKeyword:
+                            if (hasKind(node.parent, SyntaxKind.IfStatement)) {
+                                return getIfElseOccurrences(<IfStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ReturnKeyword:
+                            if (hasKind(node.parent, SyntaxKind.ReturnStatement)) {
+                                return getReturnOccurrences(<ReturnStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ThrowKeyword:
+                            if (hasKind(node.parent, SyntaxKind.ThrowStatement)) {
+                                return getThrowOccurrences(<ThrowStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.CatchKeyword:
+                            if (hasKind(parent(parent(node)), SyntaxKind.TryStatement)) {
+                                return getTryCatchFinallyOccurrences(<TryStatement>node.parent.parent);
+                            }
+                            break;
+                        case SyntaxKind.TryKeyword:
+                        case SyntaxKind.FinallyKeyword:
+                            if (hasKind(parent(node), SyntaxKind.TryStatement)) {
+                                return getTryCatchFinallyOccurrences(<TryStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.SwitchKeyword:
+                            if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
+                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.CaseKeyword:
+                        case SyntaxKind.DefaultKeyword:
+                            if (hasKind(parent(parent(parent(node))), SyntaxKind.SwitchStatement)) {
+                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent.parent.parent);
+                            }
+                            break;
+                        case SyntaxKind.BreakKeyword:
+                        case SyntaxKind.ContinueKeyword:
+                            if (hasKind(node.parent, SyntaxKind.BreakStatement) || hasKind(node.parent, SyntaxKind.ContinueStatement)) {
+                                return getBreakOrContinueStatementOccurrences(<BreakOrContinueStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ForKeyword:
+                            if (hasKind(node.parent, SyntaxKind.ForStatement) ||
+                                hasKind(node.parent, SyntaxKind.ForInStatement) ||
+                                hasKind(node.parent, SyntaxKind.ForOfStatement)) {
+                                return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.WhileKeyword:
+                        case SyntaxKind.DoKeyword:
+                            if (hasKind(node.parent, SyntaxKind.WhileStatement) || hasKind(node.parent, SyntaxKind.DoStatement)) {
+                                return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ConstructorKeyword:
+                            if (hasKind(node.parent, SyntaxKind.Constructor)) {
+                                return getConstructorOccurrences(<ConstructorDeclaration>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.GetKeyword:
+                        case SyntaxKind.SetKeyword:
+                            if (hasKind(node.parent, SyntaxKind.GetAccessor) || hasKind(node.parent, SyntaxKind.SetAccessor)) {
+                                return getGetAndSetOccurrences(<AccessorDeclaration>node.parent);
+                            }
+                            break;
+                        default:
+                            if (isModifierKind(node.kind) && node.parent &&
+                                (isDeclaration(node.parent) || node.parent.kind === SyntaxKind.VariableStatement)) {
+                                return getModifierOccurrences(node.kind, node.parent);
+                            }
+                    }
+                }
+
+                return undefined;
+            }
+
+            /**
+             * Aggregates all throw-statements within this node *without* crossing
+             * into function boundaries and try-blocks with catch-clauses.
+             */
+            function aggregateOwnedThrowStatements(node: Node): ThrowStatement[] {
+                const statementAccumulator: ThrowStatement[] = [];
+                aggregate(node);
+                return statementAccumulator;
+
+                function aggregate(node: Node): void {
+                    if (node.kind === SyntaxKind.ThrowStatement) {
+                        statementAccumulator.push(<ThrowStatement>node);
+                    }
+                    else if (node.kind === SyntaxKind.TryStatement) {
+                        const tryStatement = <TryStatement>node;
+
+                        if (tryStatement.catchClause) {
+                            aggregate(tryStatement.catchClause);
+                        }
+                        else {
+                            // Exceptions thrown within a try block lacking a catch clause
+                            // are "owned" in the current context.
+                            aggregate(tryStatement.tryBlock);
+                        }
+
+                        if (tryStatement.finallyBlock) {
+                            aggregate(tryStatement.finallyBlock);
+                        }
+                    }
+                    // Do not cross function boundaries.
+                    else if (!isFunctionLike(node)) {
+                        forEachChild(node, aggregate);
+                    }
+                }
+            }
+
+            /**
+             * For lack of a better name, this function takes a throw statement and returns the
+             * nearest ancestor that is a try-block (whose try statement has a catch clause),
+             * function-block, or source file.
+             */
+            function getThrowStatementOwner(throwStatement: ThrowStatement): Node {
+                let child: Node = throwStatement;
+
+                while (child.parent) {
+                    const parent = child.parent;
+
+                    if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
+                        return parent;
+                    }
+
+                    // A throw-statement is only owned by a try-statement if the try-statement has
+                    // a catch clause, and if the throw-statement occurs within the try block.
+                    if (parent.kind === SyntaxKind.TryStatement) {
+                        const tryStatement = <TryStatement>parent;
+
+                        if (tryStatement.tryBlock === child && tryStatement.catchClause) {
+                            return child;
+                        }
+                    }
+
+                    child = parent;
+                }
+
+                return undefined;
+            }
+
+            function aggregateAllBreakAndContinueStatements(node: Node): BreakOrContinueStatement[] {
+                const statementAccumulator: BreakOrContinueStatement[] = [];
+                aggregate(node);
+                return statementAccumulator;
+
+                function aggregate(node: Node): void {
+                    if (node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement) {
+                        statementAccumulator.push(<BreakOrContinueStatement>node);
+                    }
+                    // Do not cross function boundaries.
+                    else if (!isFunctionLike(node)) {
+                        forEachChild(node, aggregate);
+                    }
+                }
+            }
+
+            function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
+                const actualOwner = getBreakOrContinueOwner(statement);
+
+                return actualOwner && actualOwner === owner;
+            }
+
+            function getBreakOrContinueOwner(statement: BreakOrContinueStatement): Node {
+                for (let node = statement.parent; node; node = node.parent) {
+                    switch (node.kind) {
+                        case SyntaxKind.SwitchStatement:
+                            if (statement.kind === SyntaxKind.ContinueStatement) {
+                                continue;
+                            }
+                        // Fall through.
+                        case SyntaxKind.ForStatement:
+                        case SyntaxKind.ForInStatement:
+                        case SyntaxKind.ForOfStatement:
+                        case SyntaxKind.WhileStatement:
+                        case SyntaxKind.DoStatement:
+                            if (!statement.label || isLabeledBy(node, statement.label.text)) {
+                                return node;
+                            }
+                            break;
+                        default:
+                            // Don't cross function boundaries.
+                            if (isFunctionLike(node)) {
+                                return undefined;
+                            }
+                            break;
+                    }
+                }
+
+                return undefined;
+            }
+
+            function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): HighlightSpan[] {
+                const container = declaration.parent;
+
+                // Make sure we only highlight the keyword when it makes sense to do so.
+                if (isAccessibilityModifier(modifier)) {
+                    if (!(container.kind === SyntaxKind.ClassDeclaration ||
+                        container.kind === SyntaxKind.ClassExpression ||
+                        (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) {
+                        return undefined;
+                    }
+                }
+                else if (modifier === SyntaxKind.StaticKeyword) {
+                    if (!(container.kind === SyntaxKind.ClassDeclaration || container.kind === SyntaxKind.ClassExpression)) {
+                        return undefined;
+                    }
+                }
+                else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) {
+                    if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) {
+                        return undefined;
+                    }
+                }
+                else if (modifier === SyntaxKind.AbstractKeyword) {
+                    if (!(container.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.ClassDeclaration)) {
+                        return undefined;
+                    }
+                }
+                else {
+                    // unsupported modifier
+                    return undefined;
+                }
+
+                const keywords: Node[] = [];
+                const modifierFlag: ModifierFlags = getFlagFromModifier(modifier);
+
+                let nodes: Node[];
+                switch (container.kind) {
+                    case SyntaxKind.ModuleBlock:
+                    case SyntaxKind.SourceFile:
+                        // Container is either a class declaration or the declaration is a classDeclaration
+                        if (modifierFlag & ModifierFlags.Abstract) {
+                            nodes = (<Node[]>(<ClassDeclaration>declaration).members).concat(declaration);
+                        }
+                        else {
+                            nodes = (<Block>container).statements;
+                        }
+                        break;
+                    case SyntaxKind.Constructor:
+                        nodes = (<Node[]>(<ConstructorDeclaration>container).parameters).concat(
+                            (<ClassDeclaration>container.parent).members);
+                        break;
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.ClassExpression:
+                        nodes = (<ClassLikeDeclaration>container).members;
+
+                        // If we're an accessibility modifier, we're in an instance member and should search
+                        // the constructor's parameter list for instance members as well.
+                        if (modifierFlag & ModifierFlags.AccessibilityModifier) {
+                            const constructor = forEach((<ClassLikeDeclaration>container).members, member => {
+                                return member.kind === SyntaxKind.Constructor && <ConstructorDeclaration>member;
+                            });
+
+                            if (constructor) {
+                                nodes = nodes.concat(constructor.parameters);
+                            }
+                        }
+                        else if (modifierFlag & ModifierFlags.Abstract) {
+                            nodes = nodes.concat(container);
+                        }
+                        break;
+                    default:
+                        Debug.fail("Invalid container kind.");
+                }
+
+                forEach(nodes, node => {
+                    if (getModifierFlags(node) & modifierFlag) {
+                        forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier));
+                    }
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+
+                function getFlagFromModifier(modifier: SyntaxKind) {
+                    switch (modifier) {
+                        case SyntaxKind.PublicKeyword:
+                            return ModifierFlags.Public;
+                        case SyntaxKind.PrivateKeyword:
+                            return ModifierFlags.Private;
+                        case SyntaxKind.ProtectedKeyword:
+                            return ModifierFlags.Protected;
+                        case SyntaxKind.StaticKeyword:
+                            return ModifierFlags.Static;
+                        case SyntaxKind.ExportKeyword:
+                            return ModifierFlags.Export;
+                        case SyntaxKind.DeclareKeyword:
+                            return ModifierFlags.Ambient;
+                        case SyntaxKind.AbstractKeyword:
+                            return ModifierFlags.Abstract;
+                        default:
+                            Debug.fail();
+                    }
+                }
+            }
+
+            function pushKeywordIf(keywordList: Node[], token: Node, ...expected: SyntaxKind[]): boolean {
+                if (token && contains(expected, token.kind)) {
+                    keywordList.push(token);
+                    return true;
+                }
+
+                return false;
+            }
+
+            function getGetAndSetOccurrences(accessorDeclaration: AccessorDeclaration): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.GetAccessor);
+                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.SetAccessor);
+
+                return map(keywords, getHighlightSpanForNode);
+
+                function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
+                    const accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
+
+                    if (accessor) {
+                        forEach(accessor.getChildren(), child => pushKeywordIf(keywords, child, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword));
+                    }
+                }
+            }
+
+            function getConstructorOccurrences(constructorDeclaration: ConstructorDeclaration): HighlightSpan[] {
+                const declarations = constructorDeclaration.symbol.getDeclarations();
+
+                const keywords: Node[] = [];
+
+                forEach(declarations, declaration => {
+                    forEach(declaration.getChildren(), token => {
+                        return pushKeywordIf(keywords, token, SyntaxKind.ConstructorKeyword);
+                    });
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getLoopBreakContinueOccurrences(loopNode: IterationStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
+                    // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
+                    if (loopNode.kind === SyntaxKind.DoStatement) {
+                        const loopTokens = loopNode.getChildren();
+
+                        for (let i = loopTokens.length - 1; i >= 0; i--) {
+                            if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                const breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
+
+                forEach(breaksAndContinues, statement => {
+                    if (ownsBreakOrContinueStatement(loopNode, statement)) {
+                        pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
+                    }
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getBreakOrContinueStatementOccurrences(breakOrContinueStatement: BreakOrContinueStatement): HighlightSpan[] {
+                const owner = getBreakOrContinueOwner(breakOrContinueStatement);
+
+                if (owner) {
+                    switch (owner.kind) {
+                        case SyntaxKind.ForStatement:
+                        case SyntaxKind.ForInStatement:
+                        case SyntaxKind.ForOfStatement:
+                        case SyntaxKind.DoStatement:
+                        case SyntaxKind.WhileStatement:
+                            return getLoopBreakContinueOccurrences(<IterationStatement>owner);
+                        case SyntaxKind.SwitchStatement:
+                            return getSwitchCaseDefaultOccurrences(<SwitchStatement>owner);
+
+                    }
+                }
+
+                return undefined;
+            }
+
+            function getSwitchCaseDefaultOccurrences(switchStatement: SwitchStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
+
+                // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
+                forEach(switchStatement.caseBlock.clauses, clause => {
+                    pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
+
+                    const breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
+
+                    forEach(breaksAndContinues, statement => {
+                        if (ownsBreakOrContinueStatement(switchStatement, statement)) {
+                            pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
+                        }
+                    });
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getTryCatchFinallyOccurrences(tryStatement: TryStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
+
+                if (tryStatement.catchClause) {
+                    pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
+                }
+
+                if (tryStatement.finallyBlock) {
+                    const finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
+                    pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
+                }
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getThrowOccurrences(throwStatement: ThrowStatement): HighlightSpan[] {
+                const owner = getThrowStatementOwner(throwStatement);
+
+                if (!owner) {
+                    return undefined;
+                }
+
+                const keywords: Node[] = [];
+
+                forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
+                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+                });
+
+                // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
+                // ability to "jump out" of the function, and include occurrences for both.
+                if (isFunctionBlock(owner)) {
+                    forEachReturnStatement(<Block>owner, returnStatement => {
+                        pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+                    });
+                }
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getReturnOccurrences(returnStatement: ReturnStatement): HighlightSpan[] {
+                const func = <FunctionLikeDeclaration>getContainingFunction(returnStatement);
+
+                // If we didn't find a containing function with a block body, bail out.
+                if (!(func && hasKind(func.body, SyntaxKind.Block))) {
+                    return undefined;
+                }
+
+                const keywords: Node[] = [];
+                forEachReturnStatement(<Block>func.body, returnStatement => {
+                    pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+                });
+
+                // Include 'throw' statements that do not occur within a try block.
+                forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
+                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getIfElseOccurrences(ifStatement: IfStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                // Traverse upwards through all parent if-statements linked by their else-branches.
+                while (hasKind(ifStatement.parent, SyntaxKind.IfStatement) && (<IfStatement>ifStatement.parent).elseStatement === ifStatement) {
+                    ifStatement = <IfStatement>ifStatement.parent;
+                }
+
+                // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
+                while (ifStatement) {
+                    const children = ifStatement.getChildren();
+                    pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
+
+                    // Generally the 'else' keyword is second-to-last, so we traverse backwards.
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
+                            break;
+                        }
+                    }
+
+                    if (!hasKind(ifStatement.elseStatement, SyntaxKind.IfStatement)) {
+                        break;
+                    }
+
+                    ifStatement = <IfStatement>ifStatement.elseStatement;
+                }
+
+                const result: HighlightSpan[] = [];
+
+                // We'd like to highlight else/ifs together if they are only separated by whitespace
+                // (i.e. the keywords are separated by no comments, no newlines).
+                for (let i = 0; i < keywords.length; i++) {
+                    if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
+                        const elseKeyword = keywords[i];
+                        const ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+
+                        let shouldCombindElseAndIf = true;
+
+                        // Avoid recalculating getStart() by iterating backwards.
+                        for (let j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
+                            if (!isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
+                                shouldCombindElseAndIf = false;
+                                break;
+                            }
+                        }
+
+                        if (shouldCombindElseAndIf) {
+                            result.push({
+                                fileName: fileName,
+                                textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
+                                kind: HighlightSpanKind.reference
+                            });
+                            i++; // skip the next keyword
+                            continue;
+                        }
+                    }
+
+                    // Ordinary case: just highlight the keyword.
+                    result.push(getHighlightSpanForNode(keywords[i]));
+                }
+
+                return result;
+            }
+        }
+    }
+
+    /**
+     * Whether or not a 'node' is preceded by a label of the given string.
+     * Note: 'node' cannot be a SourceFile.
+     */
+    function isLabeledBy(node: Node, labelName: string) {
+        for (let owner = node.parent; owner.kind === SyntaxKind.LabeledStatement; owner = owner.parent) {
+            if ((<LabeledStatement>owner).label.text === labelName) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/services/documentRegistry.ts

@@ -0,0 +1,240 @@
+namespace ts {
+    /**
+      * The document registry represents a store of SourceFile objects that can be shared between
+      * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
+      * of files in the context.
+      * SourceFile objects account for most of the memory usage by the language service. Sharing
+      * the same DocumentRegistry instance between different instances of LanguageService allow
+      * for more efficient memory utilization since all projects will share at least the library
+      * file (lib.d.ts).
+      *
+      * A more advanced use of the document registry is to serialize sourceFile objects to disk
+      * and re-hydrate them when needed.
+      *
+      * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
+      * to all subsequent createLanguageService calls.
+      */
+    export interface DocumentRegistry {
+        /**
+          * Request a stored SourceFile with a given fileName and compilationSettings.
+          * The first call to acquire will call createLanguageServiceSourceFile to generate
+          * the SourceFile if was not found in the registry.
+          *
+          * @param fileName The name of the file requested
+          * @param compilationSettings Some compilation settings like target affects the
+          * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
+          * multiple copies of the same file for different compilation settings.
+          * @parm scriptSnapshot Text of the file. Only used if the file was not found
+          * in the registry and a new one was created.
+          * @parm version Current version of the file. Only used if the file was not found
+          * in the registry and a new one was created.
+          */
+        acquireDocument(
+            fileName: string,
+            compilationSettings: CompilerOptions,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        acquireDocumentWithKey(
+            fileName: string,
+            path: Path,
+            compilationSettings: CompilerOptions,
+            key: DocumentRegistryBucketKey,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        /**
+          * Request an updated version of an already existing SourceFile with a given fileName
+          * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
+          * to get an updated SourceFile.
+          *
+          * @param fileName The name of the file requested
+          * @param compilationSettings Some compilation settings like target affects the
+          * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
+          * multiple copies of the same file for different compilation settings.
+          * @param scriptSnapshot Text of the file.
+          * @param version Current version of the file.
+          */
+        updateDocument(
+            fileName: string,
+            compilationSettings: CompilerOptions,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        updateDocumentWithKey(
+            fileName: string,
+            path: Path,
+            compilationSettings: CompilerOptions,
+            key: DocumentRegistryBucketKey,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
+        /**
+          * Informs the DocumentRegistry that a file is not needed any longer.
+          *
+          * Note: It is not allowed to call release on a SourceFile that was not acquired from
+          * this registry originally.
+          *
+          * @param fileName The name of the file to be released
+          * @param compilationSettings The compilation settings used to acquire the file
+          */
+        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
+
+        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void;
+
+        reportStats(): string;
+    }
+
+    export type DocumentRegistryBucketKey = string & { __bucketKey: any };
+
+    interface DocumentRegistryEntry {
+        sourceFile: SourceFile;
+
+        // The number of language services that this source file is referenced in.   When no more
+        // language services are referencing the file, then the file can be removed from the
+        // registry.
+        languageServiceRefCount: number;
+        owners: string[];
+    }
+
+    export function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory = ""): DocumentRegistry {
+        // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
+        // for those settings.
+        const buckets = createMap<FileMap<DocumentRegistryEntry>>();
+        const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
+
+        function getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey {
+            return <DocumentRegistryBucketKey>`_${settings.target}|${settings.module}|${settings.noResolve}|${settings.jsx}|${settings.allowJs}|${settings.baseUrl}|${JSON.stringify(settings.typeRoots)}|${JSON.stringify(settings.rootDirs)}|${JSON.stringify(settings.paths)}`;
+        }
+
+        function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): FileMap<DocumentRegistryEntry> {
+            let bucket = buckets[key];
+            if (!bucket && createIfMissing) {
+                buckets[key] = bucket = createFileMap<DocumentRegistryEntry>();
+            }
+            return bucket;
+        }
+
+        function reportStats() {
+            const bucketInfoArray = Object.keys(buckets).filter(name => name && name.charAt(0) === "_").map(name => {
+                const entries = buckets[name];
+                const sourceFiles: { name: string; refCount: number; references: string[]; }[] = [];
+                entries.forEachValue((key, entry) => {
+                    sourceFiles.push({
+                        name: key,
+                        refCount: entry.languageServiceRefCount,
+                        references: entry.owners.slice(0)
+                    });
+                });
+                sourceFiles.sort((x, y) => y.refCount - x.refCount);
+                return {
+                    bucket: name,
+                    sourceFiles
+                };
+            });
+            return JSON.stringify(bucketInfoArray, undefined, 2);
+        }
+
+        function acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const key = getKeyForCompilationSettings(compilationSettings);
+            return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+        }
+
+        function acquireDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ true, scriptKind);
+        }
+
+        function updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const key = getKeyForCompilationSettings(compilationSettings);
+            return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+        }
+
+        function updateDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
+        }
+
+        function acquireOrUpdateDocument(
+            fileName: string,
+            path: Path,
+            compilationSettings: CompilerOptions,
+            key: DocumentRegistryBucketKey,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            acquiring: boolean,
+            scriptKind?: ScriptKind): SourceFile {
+
+            const bucket = getBucketForCompilationSettings(key, /*createIfMissing*/ true);
+            let entry = bucket.get(path);
+            if (!entry) {
+                Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?");
+
+                // Have never seen this file with these settings.  Create a new source file for it.
+                const sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, /*setNodeParents*/ false, scriptKind);
+
+                entry = {
+                    sourceFile: sourceFile,
+                    languageServiceRefCount: 0,
+                    owners: []
+                };
+                bucket.set(path, entry);
+            }
+            else {
+                // We have an entry for this file.  However, it may be for a different version of
+                // the script snapshot.  If so, update it appropriately.  Otherwise, we can just
+                // return it as is.
+                if (entry.sourceFile.version !== version) {
+                    entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version,
+                        scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
+                }
+            }
+
+            // If we're acquiring, then this is the first time this LS is asking for this document.
+            // Increase our ref count so we know there's another LS using the document.  If we're
+            // not acquiring, then that means the LS is 'updating' the file instead, and that means
+            // it has already acquired the document previously.  As such, we do not need to increase
+            // the ref count.
+            if (acquiring) {
+                entry.languageServiceRefCount++;
+            }
+
+            return entry.sourceFile;
+        }
+
+        function releaseDocument(fileName: string, compilationSettings: CompilerOptions): void {
+            const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const key = getKeyForCompilationSettings(compilationSettings);
+            return releaseDocumentWithKey(path, key);
+        }
+
+        function releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void {
+            const bucket = getBucketForCompilationSettings(key, /*createIfMissing*/false);
+            Debug.assert(bucket !== undefined);
+
+            const entry = bucket.get(path);
+            entry.languageServiceRefCount--;
+
+            Debug.assert(entry.languageServiceRefCount >= 0);
+            if (entry.languageServiceRefCount === 0) {
+                bucket.remove(path);
+            }
+        }
+
+        return {
+            acquireDocument,
+            acquireDocumentWithKey,
+            updateDocument,
+            updateDocumentWithKey,
+            releaseDocument,
+            releaseDocumentWithKey,
+            reportStats,
+            getKeyForCompilationSettings
+        };
+    }
+}

src/services/formatting/rules.ts

@@ -50,6 +50,8 @@ namespace ts.formatting {
         // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}.
         public SpaceAfterOpenBrace: Rule;
         public SpaceBeforeCloseBrace: Rule;
+        public NoSpaceAfterOpenBrace: Rule;
+        public NoSpaceBeforeCloseBrace: Rule;
         public NoSpaceBetweenEmptyBraceBrackets: Rule;
 
         // Insert new line after { and before } in multi-line contexts.
@@ -136,7 +138,6 @@ namespace ts.formatting {
         public NoSpaceAfterOpenAngularBracket: Rule;
         public NoSpaceBeforeCloseAngularBracket: Rule;
         public NoSpaceAfterCloseAngularBracket: Rule;
-        public NoSpaceAfterTypeAssertion: Rule;
 
         // Remove spaces in empty interface literals. e.g.: x: {}
         public NoSpaceBetweenEmptyInterfaceBraceBrackets: Rule;
@@ -238,6 +239,10 @@ namespace ts.formatting {
         public NoSpaceBeforeEqualInJsxAttribute: Rule;
         public NoSpaceAfterEqualInJsxAttribute: Rule;
 
+        // No space after type assertions
+        public NoSpaceAfterTypeAssertion: Rule;
+        public SpaceAfterTypeAssertion: Rule;
+
         constructor() {
             ///
             /// Common Rules
@@ -287,6 +292,8 @@ namespace ts.formatting {
             // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}.
             this.SpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSingleLineBlockContext), RuleAction.Space));
             this.SpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSingleLineBlockContext), RuleAction.Space));
+            this.NoSpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSingleLineBlockContext), RuleAction.Delete));
+            this.NoSpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsSingleLineBlockContext), RuleAction.Delete));
             this.NoSpaceBetweenEmptyBraceBrackets = new Rule(RuleDescriptor.create1(SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsObjectContext), RuleAction.Delete));
 
             // Insert new line after { and before } in multi-line contexts.
@@ -371,7 +378,6 @@ namespace ts.formatting {
             this.NoSpaceAfterOpenAngularBracket = new Rule(RuleDescriptor.create3(SyntaxKind.LessThanToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), RuleAction.Delete));
             this.NoSpaceBeforeCloseAngularBracket = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.GreaterThanToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), RuleAction.Delete));
             this.NoSpaceAfterCloseAngularBracket = new Rule(RuleDescriptor.create3(SyntaxKind.GreaterThanToken, Shared.TokenRange.FromTokens([SyntaxKind.OpenParenToken, SyntaxKind.OpenBracketToken, SyntaxKind.GreaterThanToken, SyntaxKind.CommaToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeArgumentOrParameterOrAssertionContext), RuleAction.Delete));
-            this.NoSpaceAfterTypeAssertion = new Rule(RuleDescriptor.create3(SyntaxKind.GreaterThanToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeAssertionContext), RuleAction.Delete));
 
             // Remove spaces in empty interface literals. e.g.: x: {}
             this.NoSpaceBetweenEmptyInterfaceBraceBrackets = new Rule(RuleDescriptor.create1(SyntaxKind.OpenBraceToken, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsObjectTypeContext), RuleAction.Delete));
@@ -414,7 +420,7 @@ namespace ts.formatting {
                 this.SpaceAfterPostdecrementWhenFollowedBySubtract,
                 this.SpaceAfterSubtractWhenFollowedByUnaryMinus, this.SpaceAfterSubtractWhenFollowedByPredecrement,
                 this.NoSpaceAfterCloseBrace,
-                this.SpaceAfterOpenBrace, this.SpaceBeforeCloseBrace, this.NewLineBeforeCloseBraceInBlockContext,
+                this.NewLineBeforeCloseBraceInBlockContext,
                 this.SpaceAfterCloseBrace, this.SpaceBetweenCloseBraceAndElse, this.SpaceBetweenCloseBraceAndWhile, this.NoSpaceBetweenEmptyBraceBrackets,
                 this.NoSpaceBetweenFunctionKeywordAndStar, this.SpaceAfterStarInGeneratorDeclaration,
                 this.SpaceAfterFunctionInFuncDecl, this.NewLineAfterOpenBraceInBlockContext, this.SpaceAfterGetSetInMember,
@@ -443,7 +449,6 @@ namespace ts.formatting {
                 this.NoSpaceAfterOpenAngularBracket,
                 this.NoSpaceBeforeCloseAngularBracket,
                 this.NoSpaceAfterCloseAngularBracket,
-                this.NoSpaceAfterTypeAssertion,
                 this.SpaceBeforeAt,
                 this.NoSpaceAfterAt,
                 this.SpaceAfterDecorator,
@@ -522,6 +527,11 @@ namespace ts.formatting {
             // Insert space after function keyword for anonymous functions
             this.SpaceAfterAnonymousFunctionKeyword = new Rule(RuleDescriptor.create1(SyntaxKind.FunctionKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclContext), RuleAction.Space));
             this.NoSpaceAfterAnonymousFunctionKeyword = new Rule(RuleDescriptor.create1(SyntaxKind.FunctionKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclContext), RuleAction.Delete));
+
+            // No space after type assertion
+            this.NoSpaceAfterTypeAssertion = new Rule(RuleDescriptor.create3(SyntaxKind.GreaterThanToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeAssertionContext), RuleAction.Delete));
+            this.SpaceAfterTypeAssertion = new Rule(RuleDescriptor.create3(SyntaxKind.GreaterThanToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsTypeAssertionContext), RuleAction.Space));
+
         }
 
         ///
@@ -789,7 +799,7 @@ namespace ts.formatting {
         }
 
         static NodeIsInDecoratorContext(node: Node): boolean {
-            while (isExpression(node)) {
+            while (isPartOfExpression(node)) {
                 node = node.parent;
             }
             return node.kind === SyntaxKind.Decorator;

src/services/formatting/rulesProvider.ts

@@ -81,6 +81,19 @@ namespace ts.formatting {
                 rules.push(this.globalRules.NoSpaceBetweenBrackets);
             }
 
+            // The default value of InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces is true
+            // so if the option is undefined, we should treat it as true as well
+            if (options.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces !== false) {
+                rules.push(this.globalRules.SpaceAfterOpenBrace);
+                rules.push(this.globalRules.SpaceBeforeCloseBrace);
+                rules.push(this.globalRules.NoSpaceBetweenEmptyBraceBrackets);
+            }
+            else {
+                rules.push(this.globalRules.NoSpaceAfterOpenBrace);
+                rules.push(this.globalRules.NoSpaceBeforeCloseBrace);
+                rules.push(this.globalRules.NoSpaceBetweenEmptyBraceBrackets);
+            }
+
             if (options.insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces) {
                 rules.push(this.globalRules.SpaceAfterTemplateHeadAndMiddle);
                 rules.push(this.globalRules.SpaceBeforeTemplateMiddleAndTail);
@@ -124,6 +137,13 @@ namespace ts.formatting {
                 rules.push(this.globalRules.NewLineBeforeOpenBraceInTypeScriptDeclWithBlock);
             }
 
+            if (options.insertSpaceAfterTypeAssertion) {
+                rules.push(this.globalRules.SpaceAfterTypeAssertion);
+            }
+            else {
+                rules.push(this.globalRules.NoSpaceAfterTypeAssertion);
+            }
+
             rules = rules.concat(this.globalRules.LowPriorityCommonRules);
 
             return rules;

src/services/formatting/smartIndenter.ts

@@ -208,7 +208,7 @@ namespace ts.formatting {
             // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually
             // - parent and child are not on the same line
             const useActualIndentation =
-                (isDeclaration(current) || isStatement(current)) &&
+                (isDeclaration(current) || isStatementButNotDeclaration(current)) &&
                 (parent.kind === SyntaxKind.SourceFile || !parentAndChildShareLine);
 
             if (!useActualIndentation) {

src/services/goToDefinition.ts

@@ -0,0 +1,256 @@
+/* @internal */
+namespace ts.GoToDefinition {
+    export function getDefinitionAtPosition(program: Program, sourceFile: SourceFile, position: number): DefinitionInfo[] {
+        /// Triple slash reference comments
+        const comment = findReferenceInPosition(sourceFile.referencedFiles, position);
+        if (comment) {
+            const referenceFile = tryResolveScriptReference(program, sourceFile, comment);
+            if (referenceFile) {
+                return [getDefinitionInfoForFileReference(comment.fileName, referenceFile.fileName)];
+            }
+            return undefined;
+        }
+
+        // Type reference directives
+        const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
+        if (typeReferenceDirective) {
+            const referenceFile = program.getResolvedTypeReferenceDirectives()[typeReferenceDirective.fileName];
+            if (referenceFile && referenceFile.resolvedFileName) {
+                return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
+            }
+            return undefined;
+        }
+
+        const node = getTouchingPropertyName(sourceFile, position);
+        if (node === sourceFile) {
+            return undefined;
+        }
+
+        // Labels
+        if (isJumpStatementTarget(node)) {
+            const labelName = (<Identifier>node).text;
+            const label = getTargetLabel((<BreakOrContinueStatement>node.parent), (<Identifier>node).text);
+            return label ? [createDefinitionInfo(label, ScriptElementKind.label, labelName, /*containerName*/ undefined)] : undefined;
+        }
+
+        const typeChecker = program.getTypeChecker();
+
+        const calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
+        if (calledDeclaration) {
+            return [createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration)];
+        }
+
+        let symbol = typeChecker.getSymbolAtLocation(node);
+
+        // Could not find a symbol e.g. node is string or number keyword,
+        // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
+        if (!symbol) {
+            return undefined;
+        }
+
+        // If this is an alias, and the request came at the declaration location
+        // get the aliased symbol instead. This allows for goto def on an import e.g.
+        //   import {A, B} from "mod";
+        // to jump to the implementation directly.
+        if (symbol.flags & SymbolFlags.Alias) {
+            const declaration = symbol.declarations[0];
+
+            // Go to the original declaration for cases:
+            //
+            //   (1) when the aliased symbol was declared in the location(parent).
+            //   (2) when the aliased symbol is originating from a named import.
+            //
+            if (node.kind === SyntaxKind.Identifier &&
+                (node.parent === declaration ||
+                (declaration.kind === SyntaxKind.ImportSpecifier && declaration.parent && declaration.parent.kind === SyntaxKind.NamedImports))) {
+
+                symbol = typeChecker.getAliasedSymbol(symbol);
+            }
+        }
+
+        // Because name in short-hand property assignment has two different meanings: property name and property value,
+        // using go-to-definition at such position should go to the variable declaration of the property value rather than
+        // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
+        // is performed at the location of property access, we would like to go to definition of the property in the short-hand
+        // assignment. This case and others are handled by the following code.
+        if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+            const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
+            if (!shorthandSymbol) {
+                return [];
+            }
+
+            const shorthandDeclarations = shorthandSymbol.getDeclarations();
+            const shorthandSymbolKind = SymbolDisplay.getSymbolKind(typeChecker, shorthandSymbol, node);
+            const shorthandSymbolName = typeChecker.symbolToString(shorthandSymbol);
+            const shorthandContainerName = typeChecker.symbolToString(symbol.parent, node);
+            return map(shorthandDeclarations,
+                declaration => createDefinitionInfo(declaration, shorthandSymbolKind, shorthandSymbolName, shorthandContainerName));
+        }
+
+        return getDefinitionFromSymbol(typeChecker, symbol, node);
+    }
+
+    /// Goto type
+    export function getTypeDefinitionAtPosition(typeChecker: TypeChecker, sourceFile: SourceFile, position: number): DefinitionInfo[] {
+        const node = getTouchingPropertyName(sourceFile, position);
+        if (node === sourceFile) {
+            return undefined;
+        }
+
+        const symbol = typeChecker.getSymbolAtLocation(node);
+        if (!symbol) {
+            return undefined;
+        }
+
+        const type = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+        if (!type) {
+            return undefined;
+        }
+
+        if (type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Enum)) {
+            const result: DefinitionInfo[] = [];
+            forEach((<UnionType>type).types, t => {
+                if (t.symbol) {
+                    addRange(/*to*/ result, /*from*/ getDefinitionFromSymbol(typeChecker, t.symbol, node));
+                }
+            });
+            return result;
+        }
+
+        if (!type.symbol) {
+            return undefined;
+        }
+
+        return getDefinitionFromSymbol(typeChecker, type.symbol, node);
+    }
+
+    function getDefinitionFromSymbol(typeChecker: TypeChecker, symbol: Symbol, node: Node): DefinitionInfo[] {
+        const result: DefinitionInfo[] = [];
+        const declarations = symbol.getDeclarations();
+        const { symbolName, symbolKind, containerName } = getSymbolInfo(typeChecker, symbol, node);
+
+        if (!tryAddConstructSignature(symbol, node, symbolKind, symbolName, containerName, result) &&
+            !tryAddCallSignature(symbol, node, symbolKind, symbolName, containerName, result)) {
+            // Just add all the declarations.
+            forEach(declarations, declaration => {
+                result.push(createDefinitionInfo(declaration, symbolKind, symbolName, containerName));
+            });
+        }
+
+        return result;
+
+        function tryAddConstructSignature(symbol: Symbol, location: Node, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) {
+            // Applicable only if we are in a new expression, or we are on a constructor declaration
+            // and in either case the symbol has a construct signature definition, i.e. class
+            if (isNewExpressionTarget(location) || location.kind === SyntaxKind.ConstructorKeyword) {
+                if (symbol.flags & SymbolFlags.Class) {
+                    // Find the first class-like declaration and try to get the construct signature.
+                    for (const declaration of symbol.getDeclarations()) {
+                        if (isClassLike(declaration)) {
+                            return tryAddSignature(declaration.members,
+                                                    /*selectConstructors*/ true,
+                                                    symbolKind,
+                                                    symbolName,
+                                                    containerName,
+                                                    result);
+                        }
+                    }
+
+                    Debug.fail("Expected declaration to have at least one class-like declaration");
+                }
+            }
+            return false;
+        }
+
+        function tryAddCallSignature(symbol: Symbol, location: Node, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) {
+            if (isCallExpressionTarget(location) || isNewExpressionTarget(location) || isNameOfFunctionDeclaration(location)) {
+                return tryAddSignature(symbol.declarations, /*selectConstructors*/ false, symbolKind, symbolName, containerName, result);
+            }
+            return false;
+        }
+
+        function tryAddSignature(signatureDeclarations: Declaration[], selectConstructors: boolean, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) {
+            const declarations: Declaration[] = [];
+            let definition: Declaration;
+
+            forEach(signatureDeclarations, d => {
+                if ((selectConstructors && d.kind === SyntaxKind.Constructor) ||
+                    (!selectConstructors && (d.kind === SyntaxKind.FunctionDeclaration || d.kind === SyntaxKind.MethodDeclaration || d.kind === SyntaxKind.MethodSignature))) {
+                    declarations.push(d);
+                    if ((<FunctionLikeDeclaration>d).body) definition = d;
+                }
+            });
+
+            if (definition) {
+                result.push(createDefinitionInfo(definition, symbolKind, symbolName, containerName));
+                return true;
+            }
+            else if (declarations.length) {
+                result.push(createDefinitionInfo(lastOrUndefined(declarations), symbolKind, symbolName, containerName));
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    function createDefinitionInfo(node: Node, symbolKind: string, symbolName: string, containerName: string): DefinitionInfo {
+        return {
+            fileName: node.getSourceFile().fileName,
+            textSpan: createTextSpanFromBounds(node.getStart(), node.getEnd()),
+            kind: symbolKind,
+            name: symbolName,
+            containerKind: undefined,
+            containerName
+        };
+    }
+
+    function getSymbolInfo(typeChecker: TypeChecker, symbol: Symbol, node: Node) {
+        return {
+            symbolName: typeChecker.symbolToString(symbol), // Do not get scoped name, just the name of the symbol
+            symbolKind: SymbolDisplay.getSymbolKind(typeChecker, symbol, node),
+            containerName: symbol.parent ? typeChecker.symbolToString(symbol.parent, node) : ""
+        };
+    }
+
+    function createDefinitionFromSignatureDeclaration(typeChecker: TypeChecker, decl: SignatureDeclaration): DefinitionInfo {
+        const { symbolName, symbolKind, containerName } = getSymbolInfo(typeChecker, decl.symbol, decl);
+        return createDefinitionInfo(decl, symbolKind, symbolName, containerName);
+    }
+
+    function findReferenceInPosition(refs: FileReference[], pos: number): FileReference {
+        for (const ref of refs) {
+            if (ref.pos <= pos && pos < ref.end) {
+                return ref;
+            }
+        }
+        return undefined;
+    }
+
+    function getDefinitionInfoForFileReference(name: string, targetFileName: string): DefinitionInfo {
+        return {
+            fileName: targetFileName,
+            textSpan: createTextSpanFromBounds(0, 0),
+            kind: ScriptElementKind.scriptElement,
+            name: name,
+            containerName: undefined,
+            containerKind: undefined
+        };
+    }
+
+    /** Returns a CallLikeExpression where `node` is the target being invoked. */
+    function getAncestorCallLikeExpression(node: Node): CallLikeExpression | undefined {
+        const target = climbPastManyPropertyAccesses(node);
+        const callLike = target.parent;
+        return callLike && isCallLikeExpression(callLike) && getInvokedExpression(callLike) === target && callLike;
+    }
+
+    function climbPastManyPropertyAccesses(node: Node): Node {
+        return isRightSideOfPropertyAccess(node) ? climbPastManyPropertyAccesses(node.parent) : node;
+    }
+
+    function tryGetSignatureDeclaration(typeChecker: TypeChecker, node: Node): SignatureDeclaration | undefined {
+        const callLike = getAncestorCallLikeExpression(node);
+        return callLike && typeChecker.getResolvedSignature(callLike).declaration;
+    }
+}

src/services/goToImplementation.ts

@@ -0,0 +1,27 @@
+/* @internal */
+namespace ts.GoToImplementation {
+    export function getImplementationAtPosition(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFiles: SourceFile[], node: Node): ImplementationLocation[] {
+        // If invoked directly on a shorthand property assignment, then return
+        // the declaration of the symbol being assigned (not the symbol being assigned to).
+        if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+            const result: ReferenceEntry[] = [];
+            FindAllReferences.getReferenceEntriesForShorthandPropertyAssignment(node, typeChecker, result);
+            return result.length > 0 ? result : undefined;
+        }
+        else if (node.kind === SyntaxKind.SuperKeyword || isSuperProperty(node.parent)) {
+            // References to and accesses on the super keyword only have one possible implementation, so no
+            // need to "Find all References"
+            const symbol = typeChecker.getSymbolAtLocation(node);
+            return symbol.valueDeclaration && [FindAllReferences.getReferenceEntryFromNode(symbol.valueDeclaration)];
+        }
+        else {
+            // Perform "Find all References" and retrieve only those that are implementations
+            const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken,
+                node, sourceFiles, /*findInStrings*/false, /*findInComments*/false, /*implementations*/true);
+            const result = flatMap(referencedSymbols, symbol =>
+                map(symbol.references, ({ textSpan, fileName }) => ({ textSpan, fileName })));
+
+            return result && result.length > 0 ? result : undefined;
+        }
+    }
+}

src/services/jsDoc.ts

@@ -0,0 +1,243 @@
+/* @internal */
+namespace ts.JsDoc {
+    const jsDocTagNames = [
+        "augments",
+        "author",
+        "argument",
+        "borrows",
+        "class",
+        "constant",
+        "constructor",
+        "constructs",
+        "default",
+        "deprecated",
+        "description",
+        "event",
+        "example",
+        "extends",
+        "field",
+        "fileOverview",
+        "function",
+        "ignore",
+        "inner",
+        "lends",
+        "link",
+        "memberOf",
+        "name",
+        "namespace",
+        "param",
+        "private",
+        "property",
+        "public",
+        "requires",
+        "returns",
+        "see",
+        "since",
+        "static",
+        "throws",
+        "type",
+        "typedef",
+        "property",
+        "prop",
+        "version"
+    ];
+    let jsDocCompletionEntries: CompletionEntry[];
+
+    export function getJsDocCommentsFromDeclarations(declarations: Declaration[], name: string, canUseParsedParamTagComments: boolean) {
+        // Only collect doc comments from duplicate declarations once:
+        // In case of a union property there might be same declaration multiple times
+        // which only varies in type parameter
+        // Eg. const a: Array<string> | Array<number>; a.length
+        // The property length will have two declarations of property length coming
+        // from Array<T> - Array<string> and Array<number>
+        const documentationComment = <SymbolDisplayPart[]>[];
+        forEachUnique(declarations, declaration => {
+            const comments = getJSDocComments(declaration, /*checkParentVariableStatement*/ true);
+            if (!comments) {
+                return;
+            }
+            for (const comment of comments) {
+                if (comment) {
+                    if (documentationComment.length) {
+                        documentationComment.push(lineBreakPart());
+                    }
+                    documentationComment.push(textPart(comment));
+                }
+            }
+        });
+        return documentationComment;
+    }
+
+    /**
+     * Iterates through 'array' by index and performs the callback on each element of array until the callback
+     * returns a truthy value, then returns that value.
+     * If no such value is found, the callback is applied to each element of array and undefined is returned.
+     */
+    function forEachUnique<T, U>(array: T[], callback: (element: T, index: number) => U): U {
+        if (array) {
+            for (let i = 0, len = array.length; i < len; i++) {
+                if (indexOf(array, array[i]) === i) {
+                    const result = callback(array[i], i);
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+
+    export function getAllJsDocCompletionEntries(): CompletionEntry[] {
+        return jsDocCompletionEntries || (jsDocCompletionEntries = ts.map(jsDocTagNames, tagName => {
+            return {
+                name: tagName,
+                kind: ScriptElementKind.keyword,
+                kindModifiers: "",
+                sortText: "0",
+            };
+        }));
+    }
+
+    /**
+     * Checks if position points to a valid position to add JSDoc comments, and if so,
+     * returns the appropriate template. Otherwise returns an empty string.
+     * Valid positions are
+     *      - outside of comments, statements, and expressions, and
+     *      - preceding a:
+     *          - function/constructor/method declaration
+     *          - class declarations
+     *          - variable statements
+     *          - namespace declarations
+     *
+     * Hosts should ideally check that:
+     * - The line is all whitespace up to 'position' before performing the insertion.
+     * - If the keystroke sequence "/\*\*" induced the call, we also check that the next
+     * non-whitespace character is '*', which (approximately) indicates whether we added
+     * the second '*' to complete an existing (JSDoc) comment.
+     * @param fileName The file in which to perform the check.
+     * @param position The (character-indexed) position in the file where the check should
+     * be performed.
+     */
+    export function getDocCommentTemplateAtPosition(newLine: string, sourceFile: SourceFile, position: number): TextInsertion {
+        // Check if in a context where we don't want to perform any insertion
+        if (isInString(sourceFile, position) || isInComment(sourceFile, position) || hasDocComment(sourceFile, position)) {
+            return undefined;
+        }
+
+        const tokenAtPos = getTokenAtPosition(sourceFile, position);
+        const tokenStart = tokenAtPos.getStart();
+        if (!tokenAtPos || tokenStart < position) {
+            return undefined;
+        }
+
+        // TODO: add support for:
+        // - enums/enum members
+        // - interfaces
+        // - property declarations
+        // - potentially property assignments
+        let commentOwner: Node;
+        findOwner: for (commentOwner = tokenAtPos; commentOwner; commentOwner = commentOwner.parent) {
+            switch (commentOwner.kind) {
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.VariableStatement:
+                    break findOwner;
+                case SyntaxKind.SourceFile:
+                    return undefined;
+                case SyntaxKind.ModuleDeclaration:
+                    // If in walking up the tree, we hit a a nested namespace declaration,
+                    // then we must be somewhere within a dotted namespace name; however we don't
+                    // want to give back a JSDoc template for the 'b' or 'c' in 'namespace a.b.c { }'.
+                    if (commentOwner.parent.kind === SyntaxKind.ModuleDeclaration) {
+                        return undefined;
+                    }
+                    break findOwner;
+            }
+        }
+
+        if (!commentOwner || commentOwner.getStart() < position) {
+            return undefined;
+        }
+
+        const parameters = getParametersForJsDocOwningNode(commentOwner);
+        const posLineAndChar = sourceFile.getLineAndCharacterOfPosition(position);
+        const lineStart = sourceFile.getLineStarts()[posLineAndChar.line];
+
+        const indentationStr = sourceFile.text.substr(lineStart, posLineAndChar.character);
+
+        let docParams = "";
+        for (let i = 0, numParams = parameters.length; i < numParams; i++) {
+            const currentName = parameters[i].name;
+            const paramName = currentName.kind === SyntaxKind.Identifier ?
+                (<Identifier>currentName).text :
+                "param" + i;
+
+            docParams += `${indentationStr} * @param ${paramName}${newLine}`;
+        }
+
+        // A doc comment consists of the following
+        // * The opening comment line
+        // * the first line (without a param) for the object's untagged info (this is also where the caret ends up)
+        // * the '@param'-tagged lines
+        // * TODO: other tags.
+        // * the closing comment line
+        // * if the caret was directly in front of the object, then we add an extra line and indentation.
+        const preamble = "/**" + newLine +
+            indentationStr + " * ";
+        const result =
+            preamble + newLine +
+            docParams +
+            indentationStr + " */" +
+            (tokenStart === position ? newLine + indentationStr : "");
+
+        return { newText: result, caretOffset: preamble.length };
+    }
+
+    function getParametersForJsDocOwningNode(commentOwner: Node): ParameterDeclaration[] {
+        if (isFunctionLike(commentOwner)) {
+            return commentOwner.parameters;
+        }
+
+        if (commentOwner.kind === SyntaxKind.VariableStatement) {
+            const varStatement = <VariableStatement>commentOwner;
+            const varDeclarations = varStatement.declarationList.declarations;
+
+            if (varDeclarations.length === 1 && varDeclarations[0].initializer) {
+                return getParametersFromRightHandSideOfAssignment(varDeclarations[0].initializer);
+            }
+        }
+
+        return emptyArray;
+    }
+
+    /**
+     * Digs into an an initializer or RHS operand of an assignment operation
+     * to get the parameters of an apt signature corresponding to a
+     * function expression or a class expression.
+     *
+     * @param rightHandSide the expression which may contain an appropriate set of parameters
+     * @returns the parameters of a signature found on the RHS if one exists; otherwise 'emptyArray'.
+     */
+    function getParametersFromRightHandSideOfAssignment(rightHandSide: Expression): ParameterDeclaration[] {
+        while (rightHandSide.kind === SyntaxKind.ParenthesizedExpression) {
+            rightHandSide = (<ParenthesizedExpression>rightHandSide).expression;
+        }
+
+        switch (rightHandSide.kind) {
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ArrowFunction:
+                return (<FunctionExpression>rightHandSide).parameters;
+            case SyntaxKind.ClassExpression:
+                for (const member of (<ClassExpression>rightHandSide).members) {
+                    if (member.kind === SyntaxKind.Constructor) {
+                        return (<ConstructorDeclaration>member).parameters;
+                    }
+                }
+                break;
+        }
+
+        return emptyArray;
+    }
+}

src/services/navigateTo.ts

@@ -2,7 +2,7 @@
 namespace ts.NavigateTo {
     type RawNavigateToItem = { name: string; fileName: string; matchKind: PatternMatchKind; isCaseSensitive: boolean; declaration: Declaration };
 
-    export function getNavigateToItems(program: Program, checker: TypeChecker, cancellationToken: CancellationToken, searchValue: string, maxResultCount: number, excludeDts: boolean): NavigateToItem[] {
+    export function getNavigateToItems(sourceFiles: SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken, searchValue: string, maxResultCount: number, excludeDtsFiles: boolean): NavigateToItem[] {
         const patternMatcher = createPatternMatcher(searchValue);
         let rawItems: RawNavigateToItem[] = [];
 
@@ -10,9 +10,13 @@ namespace ts.NavigateTo {
         const baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" };
 
         // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[]
-        forEach(program.getSourceFiles(), sourceFile => {
+        forEach(sourceFiles, sourceFile => {
             cancellationToken.throwIfCancellationRequested();
 
+            if (excludeDtsFiles && fileExtensionIs(sourceFile.fileName, ".d.ts")) {
+                return;
+            }
+
             const nameToDeclarations = sourceFile.getNamedDeclarations();
             for (const name in nameToDeclarations) {
                 const declarations = nameToDeclarations[name];
@@ -43,9 +47,6 @@ namespace ts.NavigateTo {
 
                         const fileName = sourceFile.fileName;
                         const matchKind = bestMatchKind(matches);
-                        if (excludeDts && fileExtensionIs(declaration.getSourceFile().fileName, ".d.ts")) {
-                            continue;
-                        }
                         rawItems.push({ name, fileName, matchKind, isCaseSensitive: allMatchesAreCaseSensitive(matches), declaration });
                     }
                 }

src/services/navigationBar.ts

@@ -218,15 +218,13 @@ namespace ts.NavigationBar {
                 break;
 
             default:
-                if (node.jsDocComments) {
-                    for (const jsDocComment of node.jsDocComments) {
-                        for (const tag of jsDocComment.tags) {
-                            if (tag.kind === SyntaxKind.JSDocTypedefTag) {
-                                addLeafNode(tag);
-                            }
+                forEach(node.jsDocComments, jsDocComment => {
+                    forEach(jsDocComment.tags, tag => {
+                        if (tag.kind === SyntaxKind.JSDocTypedefTag) {
+                            addLeafNode(tag);
                         }
-                    }
-                }
+                    });
+                });
 
                 forEachChild(node, addChildrenRecursively);
         }
@@ -397,7 +395,7 @@ namespace ts.NavigationBar {
             case SyntaxKind.FunctionExpression:
             case SyntaxKind.ClassDeclaration:
             case SyntaxKind.ClassExpression:
-                if (node.flags & NodeFlags.Default) {
+                if (getModifierFlags(node) & ModifierFlags.Default) {
                     return "default";
                 }
                 return getFunctionOrClassName(<ArrowFunction | FunctionExpression | ClassExpression>node);
@@ -466,6 +464,7 @@ namespace ts.NavigationBar {
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.GetAccessor:
                 case SyntaxKind.SetAccessor:
+                case SyntaxKind.VariableDeclaration:
                     return hasSomeImportantChild(item);
 
                 case SyntaxKind.ArrowFunction:
@@ -595,7 +594,7 @@ namespace ts.NavigationBar {
             return nodeText((node.parent as PropertyAssignment).name);
         }
         // Default exports are named "default"
-        else if (node.flags & NodeFlags.Default) {
+        else if (getModifierFlags(node) & ModifierFlags.Default) {
             return "default";
         }
         else {

src/services/preProcess.ts

@@ -0,0 +1,359 @@
+namespace ts {
+    export function preProcessFile(sourceText: string, readImportFiles = true, detectJavaScriptImports = false): PreProcessedFileInfo {
+        const referencedFiles: FileReference[] = [];
+        const typeReferenceDirectives: FileReference[] = [];
+        const importedFiles: FileReference[] = [];
+        let ambientExternalModules: { ref: FileReference, depth: number }[];
+        let isNoDefaultLib = false;
+        let braceNesting = 0;
+        // assume that text represent an external module if it contains at least one top level import/export
+        // ambient modules that are found inside external modules are interpreted as module augmentations
+        let externalModule = false;
+
+        function nextToken() {
+            const token = scanner.scan();
+            if (token === SyntaxKind.OpenBraceToken) {
+                braceNesting++;
+            }
+            else if (token === SyntaxKind.CloseBraceToken) {
+                braceNesting--;
+            }
+            return token;
+        }
+
+        function processTripleSlashDirectives(): void {
+            const commentRanges = getLeadingCommentRanges(sourceText, 0);
+            forEach(commentRanges, commentRange => {
+                const comment = sourceText.substring(commentRange.pos, commentRange.end);
+                const referencePathMatchResult = getFileReferenceFromReferencePath(comment, commentRange);
+                if (referencePathMatchResult) {
+                    isNoDefaultLib = referencePathMatchResult.isNoDefaultLib;
+                    const fileReference = referencePathMatchResult.fileReference;
+                    if (fileReference) {
+                        const collection = referencePathMatchResult.isTypeReferenceDirective
+                            ? typeReferenceDirectives
+                            : referencedFiles;
+
+                        collection.push(fileReference);
+                    }
+                }
+            });
+        }
+
+        function getFileReference() {
+            const file = scanner.getTokenValue();
+            const pos = scanner.getTokenPos();
+            return {
+                fileName: file,
+                pos: pos,
+                end: pos + file.length
+            };
+        }
+
+        function recordAmbientExternalModule(): void {
+            if (!ambientExternalModules) {
+                ambientExternalModules = [];
+            }
+            ambientExternalModules.push({ ref: getFileReference(), depth: braceNesting });
+        }
+
+        function recordModuleName() {
+            importedFiles.push(getFileReference());
+
+            markAsExternalModuleIfTopLevel();
+        }
+
+        function markAsExternalModuleIfTopLevel() {
+            if (braceNesting === 0) {
+                externalModule = true;
+            }
+        }
+
+        /**
+         * Returns true if at least one token was consumed from the stream
+         */
+        function tryConsumeDeclare(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.DeclareKeyword) {
+                // declare module "mod"
+                token = nextToken();
+                if (token === SyntaxKind.ModuleKeyword) {
+                    token = nextToken();
+                    if (token === SyntaxKind.StringLiteral) {
+                        recordAmbientExternalModule();
+                    }
+                }
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Returns true if at least one token was consumed from the stream
+         */
+        function tryConsumeImport(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.ImportKeyword) {
+
+                token = nextToken();
+                if (token === SyntaxKind.StringLiteral) {
+                    // import "mod";
+                    recordModuleName();
+                    return true;
+                }
+                else {
+                    if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                        token = nextToken();
+                        if (token === SyntaxKind.FromKeyword) {
+                            token = nextToken();
+                            if (token === SyntaxKind.StringLiteral) {
+                                // import d from "mod";
+                                recordModuleName();
+                                return true;
+                            }
+                        }
+                        else if (token === SyntaxKind.EqualsToken) {
+                            if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) {
+                                return true;
+                            }
+                        }
+                        else if (token === SyntaxKind.CommaToken) {
+                            // consume comma and keep going
+                            token = nextToken();
+                        }
+                        else {
+                            // unknown syntax
+                            return true;
+                        }
+                    }
+
+                    if (token === SyntaxKind.OpenBraceToken) {
+                        token = nextToken();
+                        // consume "{ a as B, c, d as D}" clauses
+                        // make sure that it stops on EOF
+                        while (token !== SyntaxKind.CloseBraceToken && token !== SyntaxKind.EndOfFileToken) {
+                            token = nextToken();
+                        }
+
+                        if (token === SyntaxKind.CloseBraceToken) {
+                            token = nextToken();
+                            if (token === SyntaxKind.FromKeyword) {
+                                token = nextToken();
+                                if (token === SyntaxKind.StringLiteral) {
+                                    // import {a as A} from "mod";
+                                    // import d, {a, b as B} from "mod"
+                                    recordModuleName();
+                                }
+                            }
+                        }
+                    }
+                    else if (token === SyntaxKind.AsteriskToken) {
+                        token = nextToken();
+                        if (token === SyntaxKind.AsKeyword) {
+                            token = nextToken();
+                            if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                                token = nextToken();
+                                if (token === SyntaxKind.FromKeyword) {
+                                    token = nextToken();
+                                    if (token === SyntaxKind.StringLiteral) {
+                                        // import * as NS from "mod"
+                                        // import d, * as NS from "mod"
+                                        recordModuleName();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        function tryConsumeExport(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.ExportKeyword) {
+                markAsExternalModuleIfTopLevel();
+                token = nextToken();
+                if (token === SyntaxKind.OpenBraceToken) {
+                    token = nextToken();
+                    // consume "{ a as B, c, d as D}" clauses
+                    // make sure it stops on EOF
+                    while (token !== SyntaxKind.CloseBraceToken && token !== SyntaxKind.EndOfFileToken) {
+                        token = nextToken();
+                    }
+
+                    if (token === SyntaxKind.CloseBraceToken) {
+                        token = nextToken();
+                        if (token === SyntaxKind.FromKeyword) {
+                            token = nextToken();
+                            if (token === SyntaxKind.StringLiteral) {
+                                // export {a as A} from "mod";
+                                // export {a, b as B} from "mod"
+                                recordModuleName();
+                            }
+                        }
+                    }
+                }
+                else if (token === SyntaxKind.AsteriskToken) {
+                    token = nextToken();
+                    if (token === SyntaxKind.FromKeyword) {
+                        token = nextToken();
+                        if (token === SyntaxKind.StringLiteral) {
+                            // export * from "mod"
+                            recordModuleName();
+                        }
+                    }
+                }
+                else if (token === SyntaxKind.ImportKeyword) {
+                    token = nextToken();
+                    if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                        token = nextToken();
+                        if (token === SyntaxKind.EqualsToken) {
+                            if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        function tryConsumeRequireCall(skipCurrentToken: boolean): boolean {
+            let token = skipCurrentToken ? nextToken() : scanner.getToken();
+            if (token === SyntaxKind.RequireKeyword) {
+                token = nextToken();
+                if (token === SyntaxKind.OpenParenToken) {
+                    token = nextToken();
+                    if (token === SyntaxKind.StringLiteral) {
+                        //  require("mod");
+                        recordModuleName();
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+
+        function tryConsumeDefine(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.Identifier && scanner.getTokenValue() === "define") {
+                token = nextToken();
+                if (token !== SyntaxKind.OpenParenToken) {
+                    return true;
+                }
+
+                token = nextToken();
+                if (token === SyntaxKind.StringLiteral) {
+                    // looks like define ("modname", ... - skip string literal and comma
+                    token = nextToken();
+                    if (token === SyntaxKind.CommaToken) {
+                        token = nextToken();
+                    }
+                    else {
+                        // unexpected token
+                        return true;
+                    }
+                }
+
+                // should be start of dependency list
+                if (token !== SyntaxKind.OpenBracketToken) {
+                    return true;
+                }
+
+                // skip open bracket
+                token = nextToken();
+                let i = 0;
+                // scan until ']' or EOF
+                while (token !== SyntaxKind.CloseBracketToken && token !== SyntaxKind.EndOfFileToken) {
+                    // record string literals as module names
+                    if (token === SyntaxKind.StringLiteral) {
+                        recordModuleName();
+                        i++;
+                    }
+
+                    token = nextToken();
+                }
+                return true;
+
+            }
+            return false;
+        }
+
+        function processImports(): void {
+            scanner.setText(sourceText);
+            nextToken();
+            // Look for:
+            //    import "mod";
+            //    import d from "mod"
+            //    import {a as A } from "mod";
+            //    import * as NS  from "mod"
+            //    import d, {a, b as B} from "mod"
+            //    import i = require("mod");
+            //
+            //    export * from "mod"
+            //    export {a as b} from "mod"
+            //    export import i = require("mod")
+            //    (for JavaScript files) require("mod")
+
+            while (true) {
+                if (scanner.getToken() === SyntaxKind.EndOfFileToken) {
+                    break;
+                }
+
+                // check if at least one of alternative have moved scanner forward
+                if (tryConsumeDeclare() ||
+                    tryConsumeImport() ||
+                    tryConsumeExport() ||
+                    (detectJavaScriptImports && (tryConsumeRequireCall(/*skipCurrentToken*/ false) || tryConsumeDefine()))) {
+                    continue;
+                }
+                else {
+                    nextToken();
+                }
+            }
+
+            scanner.setText(undefined);
+        }
+
+        if (readImportFiles) {
+            processImports();
+        }
+        processTripleSlashDirectives();
+        if (externalModule) {
+            // for external modules module all nested ambient modules are augmentations
+            if (ambientExternalModules) {
+                // move all detected ambient modules to imported files since they need to be resolved
+                for (const decl of ambientExternalModules) {
+                    importedFiles.push(decl.ref);
+                }
+            }
+            return { referencedFiles, typeReferenceDirectives, importedFiles, isLibFile: isNoDefaultLib, ambientExternalModules: undefined };
+        }
+        else {
+            // for global scripts ambient modules still can have augmentations - look for ambient modules with depth > 0
+            let ambientModuleNames: string[];
+            if (ambientExternalModules) {
+                for (const decl of ambientExternalModules) {
+                    if (decl.depth === 0) {
+                        if (!ambientModuleNames) {
+                            ambientModuleNames = [];
+                        }
+                        ambientModuleNames.push(decl.ref.fileName);
+                    }
+                    else {
+                        importedFiles.push(decl.ref);
+                    }
+                }
+            }
+            return { referencedFiles, typeReferenceDirectives, importedFiles, isLibFile: isNoDefaultLib, ambientExternalModules: ambientModuleNames };
+        }
+    }
+}

src/services/rename.ts

@@ -0,0 +1,98 @@
+/* @internal */
+namespace ts.Rename {
+    export function getRenameInfo(typeChecker: TypeChecker, defaultLibFileName: string, getCanonicalFileName: (fileName: string) => string, sourceFile: SourceFile, position: number): RenameInfo {
+        const canonicalDefaultLibName = getCanonicalFileName(ts.normalizePath(defaultLibFileName));
+
+        const node = getTouchingWord(sourceFile, position, /*includeJsDocComment*/ true);
+
+        if (node) {
+            if (node.kind === SyntaxKind.Identifier ||
+                node.kind === SyntaxKind.StringLiteral ||
+                isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
+                isThis(node)) {
+                const symbol = typeChecker.getSymbolAtLocation(node);
+
+                // Only allow a symbol to be renamed if it actually has at least one declaration.
+                if (symbol) {
+                    const declarations = symbol.getDeclarations();
+                    if (declarations && declarations.length > 0) {
+                        // Disallow rename for elements that are defined in the standard TypeScript library.
+                        if (forEach(declarations, isDefinedInLibraryFile)) {
+                            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
+                        }
+
+                        const displayName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
+                        const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
+                        if (kind) {
+                            return {
+                                canRename: true,
+                                kind,
+                                displayName,
+                                localizedErrorMessage: undefined,
+                                fullDisplayName: typeChecker.getFullyQualifiedName(symbol),
+                                kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
+                                triggerSpan: createTriggerSpanForNode(node, sourceFile)
+                            };
+                        }
+                    }
+                }
+                else if (node.kind === SyntaxKind.StringLiteral) {
+                    const type = getStringLiteralTypeForNode(<StringLiteral>node, typeChecker);
+                    if (type) {
+                        if (isDefinedInLibraryFile(node)) {
+                            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
+                        }
+                        else {
+                            const displayName = stripQuotes(type.text);
+                            return {
+                                canRename: true,
+                                kind: ScriptElementKind.variableElement,
+                                displayName,
+                                localizedErrorMessage: undefined,
+                                fullDisplayName: displayName,
+                                kindModifiers: ScriptElementKindModifier.none,
+                                triggerSpan: createTriggerSpanForNode(node, sourceFile)
+                            };
+                        }
+                    }
+                }
+            }
+        }
+
+        return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element));
+
+        function getRenameInfoError(localizedErrorMessage: string): RenameInfo {
+            return {
+                canRename: false,
+                localizedErrorMessage: localizedErrorMessage,
+                displayName: undefined,
+                fullDisplayName: undefined,
+                kind: undefined,
+                kindModifiers: undefined,
+                triggerSpan: undefined
+            };
+        }
+
+        function isDefinedInLibraryFile(declaration: Node) {
+            if (defaultLibFileName) {
+                const sourceFile = declaration.getSourceFile();
+                const canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName));
+                if (canonicalName === canonicalDefaultLibName) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        function createTriggerSpanForNode(node: Node, sourceFile: SourceFile) {
+            let start = node.getStart(sourceFile);
+            let width = node.getWidth(sourceFile);
+            if (node.kind === SyntaxKind.StringLiteral) {
+                // Exclude the quotes
+                start += 1;
+                width -= 2;
+            }
+            return createTextSpan(start, width);
+        }
+    }
+}

src/services/shims.ts

@@ -178,6 +178,12 @@ namespace ts {
          */
         getTypeDefinitionAtPosition(fileName: string, position: number): string;
 
+        /**
+         * Returns a JSON-encoded value of the type:
+         * { fileName: string; textSpan: { start: number; length: number}; }[]
+         */
+        getImplementationAtPosition(fileName: string, position: number): string;
+
         /**
          * Returns a JSON-encoded value of the type:
          * { fileName: string; textSpan: { start: number; length: number}; isWriteAccess: boolean, isDefinition?: boolean }[]
@@ -210,7 +216,7 @@ namespace ts {
          * Returns a JSON-encoded value of the type:
          * { name: string; kind: string; kindModifiers: string; containerName: string; containerKind: string; matchKind: string; fileName: string; textSpan: { start: number; length: number}; } [] = [];
          */
-        getNavigateToItems(searchValue: string, maxResultCount?: number): string;
+        getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string): string;
 
         /**
          * Returns a JSON-encoded value of the type:
@@ -596,6 +602,21 @@ namespace ts {
         }
     }
 
+    export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; code: number; }[] {
+        return diagnostics.map(d => realizeDiagnostic(d, newLine));
+    }
+
+    function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; code: number; } {
+        return {
+            message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
+            start: diagnostic.start,
+            length: diagnostic.length,
+            /// TODO: no need for the tolowerCase call
+            category: DiagnosticCategory[diagnostic.category].toLowerCase(),
+            code: diagnostic.code
+        };
+    }
+
     class LanguageServiceShimObject extends ShimBase implements LanguageServiceShim {
         private logger: Logger;
         private logPerformance = false;
@@ -791,6 +812,19 @@ namespace ts {
             );
         }
 
+        /// GOTO Implementation
+
+        /**
+         * Computes the implementation location of the symbol
+         * at the requested position.
+         */
+        public getImplementationAtPosition(fileName: string, position: number): string {
+            return this.forwardJSONCall(
+                `getImplementationAtPosition('${fileName}', ${position})`,
+                () => this.languageService.getImplementationAtPosition(fileName, position)
+            );
+        }
+
         public getRenameInfo(fileName: string, position: number): string {
             return this.forwardJSONCall(
                 `getRenameInfo('${fileName}', ${position})`,
@@ -923,10 +957,10 @@ namespace ts {
         /// NAVIGATE TO
 
         /** Return a list of symbols that are interesting to navigate to */
-        public getNavigateToItems(searchValue: string, maxResultCount?: number): string {
+        public getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string): string {
             return this.forwardJSONCall(
-                `getNavigateToItems('${searchValue}', ${maxResultCount})`,
-                () => this.languageService.getNavigateToItems(searchValue, maxResultCount)
+                `getNavigateToItems('${searchValue}', ${maxResultCount}, ${fileName})`,
+                () => this.languageService.getNavigateToItems(searchValue, maxResultCount, fileName)
             );
         }
 

src/services/symbolDisplay.ts

@@ -0,0 +1,523 @@
+/* @internal */
+namespace ts.SymbolDisplay {
+    // TODO(drosen): use contextual SemanticMeaning.
+    export function getSymbolKind(typeChecker: TypeChecker, symbol: Symbol, location: Node): string {
+        const flags = symbol.getFlags();
+
+        if (flags & SymbolFlags.Class) return getDeclarationOfKind(symbol, SyntaxKind.ClassExpression) ?
+            ScriptElementKind.localClassElement : ScriptElementKind.classElement;
+        if (flags & SymbolFlags.Enum) return ScriptElementKind.enumElement;
+        if (flags & SymbolFlags.TypeAlias) return ScriptElementKind.typeElement;
+        if (flags & SymbolFlags.Interface) return ScriptElementKind.interfaceElement;
+        if (flags & SymbolFlags.TypeParameter) return ScriptElementKind.typeParameterElement;
+
+        const result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, flags, location);
+        if (result === ScriptElementKind.unknown) {
+            if (flags & SymbolFlags.TypeParameter) return ScriptElementKind.typeParameterElement;
+            if (flags & SymbolFlags.EnumMember) return ScriptElementKind.variableElement;
+            if (flags & SymbolFlags.Alias) return ScriptElementKind.alias;
+            if (flags & SymbolFlags.Module) return ScriptElementKind.moduleElement;
+        }
+
+        return result;
+    }
+
+    function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker: TypeChecker, symbol: Symbol, flags: SymbolFlags, location: Node) {
+        if (typeChecker.isUndefinedSymbol(symbol)) {
+            return ScriptElementKind.variableElement;
+        }
+        if (typeChecker.isArgumentsSymbol(symbol)) {
+            return ScriptElementKind.localVariableElement;
+        }
+        if (location.kind === SyntaxKind.ThisKeyword && isExpression(location)) {
+            return ScriptElementKind.parameterElement;
+        }
+        if (flags & SymbolFlags.Variable) {
+            if (isFirstDeclarationOfSymbolParameter(symbol)) {
+                return ScriptElementKind.parameterElement;
+            }
+            else if (symbol.valueDeclaration && isConst(symbol.valueDeclaration)) {
+                return ScriptElementKind.constElement;
+            }
+            else if (forEach(symbol.declarations, isLet)) {
+                return ScriptElementKind.letElement;
+            }
+            return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
+        }
+        if (flags & SymbolFlags.Function) return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localFunctionElement : ScriptElementKind.functionElement;
+        if (flags & SymbolFlags.GetAccessor) return ScriptElementKind.memberGetAccessorElement;
+        if (flags & SymbolFlags.SetAccessor) return ScriptElementKind.memberSetAccessorElement;
+        if (flags & SymbolFlags.Method) return ScriptElementKind.memberFunctionElement;
+        if (flags & SymbolFlags.Constructor) return ScriptElementKind.constructorImplementationElement;
+
+        if (flags & SymbolFlags.Property) {
+            if (flags & SymbolFlags.SyntheticProperty) {
+                // If union property is result of union of non method (property/accessors/variables), it is labeled as property
+                const unionPropertyKind = forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
+                    const rootSymbolFlags = rootSymbol.getFlags();
+                    if (rootSymbolFlags & (SymbolFlags.PropertyOrAccessor | SymbolFlags.Variable)) {
+                        return ScriptElementKind.memberVariableElement;
+                    }
+                    Debug.assert(!!(rootSymbolFlags & SymbolFlags.Method));
+                });
+                if (!unionPropertyKind) {
+                    // If this was union of all methods,
+                    // make sure it has call signatures before we can label it as method
+                    const typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+                    if (typeOfUnionProperty.getCallSignatures().length) {
+                        return ScriptElementKind.memberFunctionElement;
+                    }
+                    return ScriptElementKind.memberVariableElement;
+                }
+                return unionPropertyKind;
+            }
+            return ScriptElementKind.memberVariableElement;
+        }
+
+        return ScriptElementKind.unknown;
+    }
+
+    export function getSymbolModifiers(symbol: Symbol): string {
+        return symbol && symbol.declarations && symbol.declarations.length > 0
+            ? getNodeModifiers(symbol.declarations[0])
+            : ScriptElementKindModifier.none;
+    }
+
+    // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location
+    export function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker: TypeChecker, symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node,
+        location: Node, semanticMeaning = getMeaningFromLocation(location)) {
+
+        const displayParts: SymbolDisplayPart[] = [];
+        let documentation: SymbolDisplayPart[];
+        const symbolFlags = symbol.flags;
+        let symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, symbolFlags, location);
+        let hasAddedSymbolInfo: boolean;
+        const isThisExpression = location.kind === SyntaxKind.ThisKeyword && isExpression(location);
+        let type: Type;
+
+        // Class at constructor site need to be shown as constructor apart from property,method, vars
+        if (symbolKind !== ScriptElementKind.unknown || symbolFlags & SymbolFlags.Class || symbolFlags & SymbolFlags.Alias) {
+            // If it is accessor they are allowed only if location is at name of the accessor
+            if (symbolKind === ScriptElementKind.memberGetAccessorElement || symbolKind === ScriptElementKind.memberSetAccessorElement) {
+                symbolKind = ScriptElementKind.memberVariableElement;
+            }
+
+            let signature: Signature;
+            type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+            if (type) {
+                if (location.parent && location.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                    const right = (<PropertyAccessExpression>location.parent).name;
+                    // Either the location is on the right of a property access, or on the left and the right is missing
+                    if (right === location || (right && right.getFullWidth() === 0)) {
+                        location = location.parent;
+                    }
+                }
+
+                // try get the call/construct signature from the type if it matches
+                let callExpression: CallExpression;
+                if (location.kind === SyntaxKind.CallExpression || location.kind === SyntaxKind.NewExpression) {
+                    callExpression = <CallExpression>location;
+                }
+                else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) {
+                    callExpression = <CallExpression>location.parent;
+                }
+
+                if (callExpression) {
+                    const candidateSignatures: Signature[] = [];
+                    signature = typeChecker.getResolvedSignature(callExpression, candidateSignatures);
+                    if (!signature && candidateSignatures.length) {
+                        // Use the first candidate:
+                        signature = candidateSignatures[0];
+                    }
+
+                    const useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.expression.kind === SyntaxKind.SuperKeyword;
+                    const allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
+
+                    if (!contains(allSignatures, signature.target) && !contains(allSignatures, signature)) {
+                        // Get the first signature if there is one -- allSignatures may contain
+                        // either the original signature or its target, so check for either
+                        signature = allSignatures.length ? allSignatures[0] : undefined;
+                    }
+
+                    if (signature) {
+                        if (useConstructSignatures && (symbolFlags & SymbolFlags.Class)) {
+                            // Constructor
+                            symbolKind = ScriptElementKind.constructorImplementationElement;
+                            addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                        }
+                        else if (symbolFlags & SymbolFlags.Alias) {
+                            symbolKind = ScriptElementKind.alias;
+                            pushTypePart(symbolKind);
+                            displayParts.push(spacePart());
+                            if (useConstructSignatures) {
+                                displayParts.push(keywordPart(SyntaxKind.NewKeyword));
+                                displayParts.push(spacePart());
+                            }
+                            addFullSymbolName(symbol);
+                        }
+                        else {
+                            addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                        }
+
+                        switch (symbolKind) {
+                            case ScriptElementKind.memberVariableElement:
+                            case ScriptElementKind.variableElement:
+                            case ScriptElementKind.constElement:
+                            case ScriptElementKind.letElement:
+                            case ScriptElementKind.parameterElement:
+                            case ScriptElementKind.localVariableElement:
+                                // If it is call or construct signature of lambda's write type name
+                                displayParts.push(punctuationPart(SyntaxKind.ColonToken));
+                                displayParts.push(spacePart());
+                                if (useConstructSignatures) {
+                                    displayParts.push(keywordPart(SyntaxKind.NewKeyword));
+                                    displayParts.push(spacePart());
+                                }
+                                if (!(type.flags & TypeFlags.Anonymous) && type.symbol) {
+                                    addRange(displayParts, symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, /*meaning*/ undefined, SymbolFormatFlags.WriteTypeParametersOrArguments));
+                                }
+                                addSignatureDisplayParts(signature, allSignatures, TypeFormatFlags.WriteArrowStyleSignature);
+                                break;
+
+                            default:
+                                // Just signature
+                                addSignatureDisplayParts(signature, allSignatures);
+                        }
+                        hasAddedSymbolInfo = true;
+                    }
+                }
+                else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & SymbolFlags.Accessor)) || // name of function declaration
+                    (location.kind === SyntaxKind.ConstructorKeyword && location.parent.kind === SyntaxKind.Constructor)) { // At constructor keyword of constructor declaration
+                    // get the signature from the declaration and write it
+                    const functionDeclaration = <FunctionLikeDeclaration>location.parent;
+                    const allSignatures = functionDeclaration.kind === SyntaxKind.Constructor ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures();
+                    if (!typeChecker.isImplementationOfOverload(functionDeclaration)) {
+                        signature = typeChecker.getSignatureFromDeclaration(functionDeclaration);
+                    }
+                    else {
+                        signature = allSignatures[0];
+                    }
+
+                    if (functionDeclaration.kind === SyntaxKind.Constructor) {
+                        // show (constructor) Type(...) signature
+                        symbolKind = ScriptElementKind.constructorImplementationElement;
+                        addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                    }
+                    else {
+                        // (function/method) symbol(..signature)
+                        addPrefixForAnyFunctionOrVar(functionDeclaration.kind === SyntaxKind.CallSignature &&
+                            !(type.symbol.flags & SymbolFlags.TypeLiteral || type.symbol.flags & SymbolFlags.ObjectLiteral) ? type.symbol : symbol, symbolKind);
+                    }
+
+                    addSignatureDisplayParts(signature, allSignatures);
+                    hasAddedSymbolInfo = true;
+                }
+            }
+        }
+        if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo && !isThisExpression) {
+            if (getDeclarationOfKind(symbol, SyntaxKind.ClassExpression)) {
+                // Special case for class expressions because we would like to indicate that
+                // the class name is local to the class body (similar to function expression)
+                //      (local class) class <className>
+                pushTypePart(ScriptElementKind.localClassElement);
+            }
+            else {
+                // Class declaration has name which is not local.
+                displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
+            }
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            writeTypeParametersOfSymbol(symbol, sourceFile);
+        }
+        if ((symbolFlags & SymbolFlags.Interface) && (semanticMeaning & SemanticMeaning.Type)) {
+            addNewLineIfDisplayPartsExist();
+            displayParts.push(keywordPart(SyntaxKind.InterfaceKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            writeTypeParametersOfSymbol(symbol, sourceFile);
+        }
+        if (symbolFlags & SymbolFlags.TypeAlias) {
+            addNewLineIfDisplayPartsExist();
+            displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            writeTypeParametersOfSymbol(symbol, sourceFile);
+            displayParts.push(spacePart());
+            displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+            displayParts.push(spacePart());
+            addRange(displayParts, typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, TypeFormatFlags.InTypeAlias));
+        }
+        if (symbolFlags & SymbolFlags.Enum) {
+            addNewLineIfDisplayPartsExist();
+            if (forEach(symbol.declarations, isConstEnumDeclaration)) {
+                displayParts.push(keywordPart(SyntaxKind.ConstKeyword));
+                displayParts.push(spacePart());
+            }
+            displayParts.push(keywordPart(SyntaxKind.EnumKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+        }
+        if (symbolFlags & SymbolFlags.Module) {
+            addNewLineIfDisplayPartsExist();
+            const declaration = <ModuleDeclaration>getDeclarationOfKind(symbol, SyntaxKind.ModuleDeclaration);
+            const isNamespace = declaration && declaration.name && declaration.name.kind === SyntaxKind.Identifier;
+            displayParts.push(keywordPart(isNamespace ? SyntaxKind.NamespaceKeyword : SyntaxKind.ModuleKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+        }
+        if ((symbolFlags & SymbolFlags.TypeParameter) && (semanticMeaning & SemanticMeaning.Type)) {
+            addNewLineIfDisplayPartsExist();
+            displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+            displayParts.push(textPart("type parameter"));
+            displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            displayParts.push(spacePart());
+            displayParts.push(keywordPart(SyntaxKind.InKeyword));
+            displayParts.push(spacePart());
+            if (symbol.parent) {
+                // Class/Interface type parameter
+                addFullSymbolName(symbol.parent, enclosingDeclaration);
+                writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration);
+            }
+            else {
+                // Method/function type parameter
+                let declaration = <Node>getDeclarationOfKind(symbol, SyntaxKind.TypeParameter);
+                Debug.assert(declaration !== undefined);
+                declaration = declaration.parent;
+
+                if (declaration) {
+                    if (isFunctionLikeKind(declaration.kind)) {
+                        const signature = typeChecker.getSignatureFromDeclaration(<SignatureDeclaration>declaration);
+                        if (declaration.kind === SyntaxKind.ConstructSignature) {
+                            displayParts.push(keywordPart(SyntaxKind.NewKeyword));
+                            displayParts.push(spacePart());
+                        }
+                        else if (declaration.kind !== SyntaxKind.CallSignature && (<SignatureDeclaration>declaration).name) {
+                            addFullSymbolName(declaration.symbol);
+                        }
+                        addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, TypeFormatFlags.WriteTypeArgumentsOfSignature));
+                    }
+                    else {
+                        // Type alias type parameter
+                        // For example
+                        //      type list<T> = T[];  // Both T will go through same code path
+                        displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+                        displayParts.push(spacePart());
+                        addFullSymbolName(declaration.symbol);
+                        writeTypeParametersOfSymbol(declaration.symbol, sourceFile);
+                    }
+                }
+            }
+        }
+        if (symbolFlags & SymbolFlags.EnumMember) {
+            addPrefixForAnyFunctionOrVar(symbol, "enum member");
+            const declaration = symbol.declarations[0];
+            if (declaration.kind === SyntaxKind.EnumMember) {
+                const constantValue = typeChecker.getConstantValue(<EnumMember>declaration);
+                if (constantValue !== undefined) {
+                    displayParts.push(spacePart());
+                    displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+                    displayParts.push(spacePart());
+                    displayParts.push(displayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
+                }
+            }
+        }
+        if (symbolFlags & SymbolFlags.Alias) {
+            addNewLineIfDisplayPartsExist();
+            if (symbol.declarations[0].kind === SyntaxKind.NamespaceExportDeclaration) {
+                displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
+                displayParts.push(spacePart());
+                displayParts.push(keywordPart(SyntaxKind.NamespaceKeyword));
+            }
+            else {
+                displayParts.push(keywordPart(SyntaxKind.ImportKeyword));
+            }
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            ts.forEach(symbol.declarations, declaration => {
+                if (declaration.kind === SyntaxKind.ImportEqualsDeclaration) {
+                    const importEqualsDeclaration = <ImportEqualsDeclaration>declaration;
+                    if (isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) {
+                        displayParts.push(spacePart());
+                        displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+                        displayParts.push(spacePart());
+                        displayParts.push(keywordPart(SyntaxKind.RequireKeyword));
+                        displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                        displayParts.push(displayPart(getTextOfNode(getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral));
+                        displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                    }
+                    else {
+                        const internalAliasSymbol = typeChecker.getSymbolAtLocation(importEqualsDeclaration.moduleReference);
+                        if (internalAliasSymbol) {
+                            displayParts.push(spacePart());
+                            displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+                            displayParts.push(spacePart());
+                            addFullSymbolName(internalAliasSymbol, enclosingDeclaration);
+                        }
+                    }
+                    return true;
+                }
+            });
+        }
+        if (!hasAddedSymbolInfo) {
+            if (symbolKind !== ScriptElementKind.unknown) {
+                if (type) {
+                    if (isThisExpression) {
+                        addNewLineIfDisplayPartsExist();
+                        displayParts.push(keywordPart(SyntaxKind.ThisKeyword));
+                    }
+                    else {
+                        addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                    }
+
+                    // For properties, variables and local vars: show the type
+                    if (symbolKind === ScriptElementKind.memberVariableElement ||
+                        symbolFlags & SymbolFlags.Variable ||
+                        symbolKind === ScriptElementKind.localVariableElement ||
+                        isThisExpression) {
+                        displayParts.push(punctuationPart(SyntaxKind.ColonToken));
+                        displayParts.push(spacePart());
+                        // If the type is type parameter, format it specially
+                        if (type.symbol && type.symbol.flags & SymbolFlags.TypeParameter) {
+                            const typeParameterParts = mapToDisplayParts(writer => {
+                                typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplay(<TypeParameter>type, writer, enclosingDeclaration);
+                            });
+                            addRange(displayParts, typeParameterParts);
+                        }
+                        else {
+                            addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
+                        }
+                    }
+                    else if (symbolFlags & SymbolFlags.Function ||
+                        symbolFlags & SymbolFlags.Method ||
+                        symbolFlags & SymbolFlags.Constructor ||
+                        symbolFlags & SymbolFlags.Signature ||
+                        symbolFlags & SymbolFlags.Accessor ||
+                        symbolKind === ScriptElementKind.memberFunctionElement) {
+                        const allSignatures = type.getNonNullableType().getCallSignatures();
+                        addSignatureDisplayParts(allSignatures[0], allSignatures);
+                    }
+                }
+            }
+            else {
+                symbolKind = getSymbolKind(typeChecker, symbol, location);
+            }
+        }
+
+        if (!documentation) {
+            documentation = symbol.getDocumentationComment();
+            if (documentation.length === 0 && symbol.flags & SymbolFlags.Property) {
+                // For some special property access expressions like `experts.foo = foo` or `module.exports.foo = foo`
+                // there documentation comments might be attached to the right hand side symbol of their declarations.
+                // The pattern of such special property access is that the parent symbol is the symbol of the file.
+                if (symbol.parent && forEach(symbol.parent.declarations, declaration => declaration.kind === SyntaxKind.SourceFile)) {
+                    for (const declaration of symbol.declarations) {
+                        if (!declaration.parent || declaration.parent.kind !== SyntaxKind.BinaryExpression) {
+                            continue;
+                        }
+
+                        const rhsSymbol = typeChecker.getSymbolAtLocation((<BinaryExpression>declaration.parent).right);
+                        if (!rhsSymbol) {
+                            continue;
+                        }
+
+                        documentation = rhsSymbol.getDocumentationComment();
+                        if (documentation.length > 0) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        return { displayParts, documentation, symbolKind };
+
+        function addNewLineIfDisplayPartsExist() {
+            if (displayParts.length) {
+                displayParts.push(lineBreakPart());
+            }
+        }
+
+        function addFullSymbolName(symbol: Symbol, enclosingDeclaration?: Node) {
+            const fullSymbolDisplayParts = symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration || sourceFile, /*meaning*/ undefined,
+                SymbolFormatFlags.WriteTypeParametersOrArguments | SymbolFormatFlags.UseOnlyExternalAliasing);
+            addRange(displayParts, fullSymbolDisplayParts);
+        }
+
+        function addPrefixForAnyFunctionOrVar(symbol: Symbol, symbolKind: string) {
+            addNewLineIfDisplayPartsExist();
+            if (symbolKind) {
+                pushTypePart(symbolKind);
+                displayParts.push(spacePart());
+                addFullSymbolName(symbol);
+            }
+        }
+
+        function pushTypePart(symbolKind: string) {
+            switch (symbolKind) {
+                case ScriptElementKind.variableElement:
+                case ScriptElementKind.functionElement:
+                case ScriptElementKind.letElement:
+                case ScriptElementKind.constElement:
+                case ScriptElementKind.constructorImplementationElement:
+                    displayParts.push(textOrKeywordPart(symbolKind));
+                    return;
+                default:
+                    displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                    displayParts.push(textOrKeywordPart(symbolKind));
+                    displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                    return;
+            }
+        }
+
+        function addSignatureDisplayParts(signature: Signature, allSignatures: Signature[], flags?: TypeFormatFlags) {
+            addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | TypeFormatFlags.WriteTypeArgumentsOfSignature));
+            if (allSignatures.length > 1) {
+                displayParts.push(spacePart());
+                displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                displayParts.push(operatorPart(SyntaxKind.PlusToken));
+                displayParts.push(displayPart((allSignatures.length - 1).toString(), SymbolDisplayPartKind.numericLiteral));
+                displayParts.push(spacePart());
+                displayParts.push(textPart(allSignatures.length === 2 ? "overload" : "overloads"));
+                displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+            }
+            documentation = signature.getDocumentationComment();
+        }
+
+        function writeTypeParametersOfSymbol(symbol: Symbol, enclosingDeclaration: Node) {
+            const typeParameterParts = mapToDisplayParts(writer => {
+                typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration);
+            });
+            addRange(displayParts, typeParameterParts);
+        }
+    }
+
+    function isLocalVariableOrFunction(symbol: Symbol) {
+        if (symbol.parent) {
+            return false; // This is exported symbol
+        }
+
+        return ts.forEach(symbol.declarations, declaration => {
+            // Function expressions are local
+            if (declaration.kind === SyntaxKind.FunctionExpression) {
+                return true;
+            }
+
+            if (declaration.kind !== SyntaxKind.VariableDeclaration && declaration.kind !== SyntaxKind.FunctionDeclaration) {
+                return false;
+            }
+
+            // If the parent is not sourceFile or module block it is local variable
+            for (let parent = declaration.parent; !isFunctionBlock(parent); parent = parent.parent) {
+                // Reached source file or module block
+                if (parent.kind === SyntaxKind.SourceFile || parent.kind === SyntaxKind.ModuleBlock) {
+                    return false;
+                }
+            }
+
+            // parent is in function block
+            return true;
+        });
+    }
+}

src/services/transpile.ts

@@ -0,0 +1,154 @@
+namespace ts {
+    export interface TranspileOptions {
+        compilerOptions?: CompilerOptions;
+        fileName?: string;
+        reportDiagnostics?: boolean;
+        moduleName?: string;
+        renamedDependencies?: MapLike<string>;
+    }
+
+    export interface TranspileOutput {
+        outputText: string;
+        diagnostics?: Diagnostic[];
+        sourceMapText?: string;
+    }
+
+    /*
+     * This function will compile source text from 'input' argument using specified compiler options.
+     * If not options are provided - it will use a set of default compiler options.
+     * Extra compiler options that will unconditionally be used by this function are:
+     * - isolatedModules = true
+     * - allowNonTsExtensions = true
+     * - noLib = true
+     * - noResolve = true
+     */
+    export function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput {
+        const diagnostics: Diagnostic[] = [];
+
+        const options: CompilerOptions = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : getDefaultCompilerOptions();
+
+        options.isolatedModules = true;
+
+        // transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
+        options.suppressOutputPathCheck = true;
+
+        // Filename can be non-ts file.
+        options.allowNonTsExtensions = true;
+
+        // We are not returning a sourceFile for lib file when asked by the program,
+        // so pass --noLib to avoid reporting a file not found error.
+        options.noLib = true;
+
+        // Clear out other settings that would not be used in transpiling this module
+        options.lib = undefined;
+        options.types = undefined;
+        options.noEmit = undefined;
+        options.noEmitOnError = undefined;
+        options.paths = undefined;
+        options.rootDirs = undefined;
+        options.declaration = undefined;
+        options.declarationDir = undefined;
+        options.out = undefined;
+        options.outFile = undefined;
+
+        // We are not doing a full typecheck, we are not resolving the whole context,
+        // so pass --noResolve to avoid reporting missing file errors.
+        options.noResolve = true;
+
+        // if jsx is specified then treat file as .tsx
+        const inputFileName = transpileOptions.fileName || (options.jsx ? "module.tsx" : "module.ts");
+        const sourceFile = createSourceFile(inputFileName, input, options.target);
+        if (transpileOptions.moduleName) {
+            sourceFile.moduleName = transpileOptions.moduleName;
+        }
+
+        if (transpileOptions.renamedDependencies) {
+            sourceFile.renamedDependencies = createMap(transpileOptions.renamedDependencies);
+        }
+
+        const newLine = getNewLineCharacter(options);
+
+        // Output
+        let outputText: string;
+        let sourceMapText: string;
+
+        // Create a compilerHost object to allow the compiler to read and write files
+        const compilerHost: CompilerHost = {
+            getSourceFile: (fileName, target) => fileName === normalizePath(inputFileName) ? sourceFile : undefined,
+            writeFile: (name, text, writeByteOrderMark) => {
+                if (fileExtensionIs(name, ".map")) {
+                    Debug.assert(sourceMapText === undefined, `Unexpected multiple source map outputs for the file '${name}'`);
+                    sourceMapText = text;
+                }
+                else {
+                    Debug.assert(outputText === undefined, `Unexpected multiple outputs for the file: '${name}'`);
+                    outputText = text;
+                }
+            },
+            getDefaultLibFileName: () => "lib.d.ts",
+            useCaseSensitiveFileNames: () => false,
+            getCanonicalFileName: fileName => fileName,
+            getCurrentDirectory: () => "",
+            getNewLine: () => newLine,
+            fileExists: (fileName): boolean => fileName === inputFileName,
+            readFile: (fileName): string => "",
+            directoryExists: directoryExists => true,
+            getDirectories: (path: string) => []
+        };
+
+        const program = createProgram([inputFileName], options, compilerHost);
+
+        if (transpileOptions.reportDiagnostics) {
+            addRange(/*to*/ diagnostics, /*from*/ program.getSyntacticDiagnostics(sourceFile));
+            addRange(/*to*/ diagnostics, /*from*/ program.getOptionsDiagnostics());
+        }
+        // Emit
+        program.emit();
+
+        Debug.assert(outputText !== undefined, "Output generation failed");
+
+        return { outputText, diagnostics, sourceMapText };
+    }
+
+    /*
+     * This is a shortcut function for transpileModule - it accepts transpileOptions as parameters and returns only outputText part of the result.
+     */
+    export function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string {
+        const output = transpileModule(input, { compilerOptions, fileName, reportDiagnostics: !!diagnostics, moduleName });
+        // addRange correctly handles cases when wither 'from' or 'to' argument is missing
+        addRange(diagnostics, output.diagnostics);
+        return output.outputText;
+    }
+
+    let commandLineOptionsStringToEnum: CommandLineOptionOfCustomType[];
+
+    /** JS users may pass in string values for enum compiler options (such as ModuleKind), so convert. */
+    function fixupCompilerOptions(options: CompilerOptions, diagnostics: Diagnostic[]): CompilerOptions {
+        // Lazily create this value to fix module loading errors.
+        commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
+            typeof o.type === "object" && !forEachProperty(o.type, v => typeof v !== "number"));
+
+        options = clone(options);
+
+        for (const opt of commandLineOptionsStringToEnum) {
+            if (!hasProperty(options, opt.name)) {
+                continue;
+            }
+
+            const value = options[opt.name];
+            // Value should be a key of opt.type
+            if (typeof value === "string") {
+                // If value is not a string, this will fail
+                options[opt.name] = parseCustomTypeOption(opt, value, diagnostics);
+            }
+            else {
+                if (!forEachProperty(opt.type, v => v === value)) {
+                    // Supplied value isn't a valid enum value.
+                    diagnostics.push(createCompilerDiagnosticForInvalidCustomType(opt));
+                }
+            }
+        }
+
+        return options;
+    }
+}

src/services/tsconfig.json

@@ -21,22 +21,48 @@
         "../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/es7.ts",
+        "../compiler/transformers/es6.ts",
+        "../compiler/transformers/generators.ts",
+        "../compiler/transformers/destructuring.ts",
+        "../compiler/transformers/module/module.ts",
+        "../compiler/transformers/module/system.ts",
+        "../compiler/transformers/module/es6.ts",
+        "../compiler/transformer.ts",
+        "../compiler/comments.ts",
         "../compiler/sourcemap.ts",
         "../compiler/declarationEmitter.ts",
         "../compiler/emitter.ts",
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",
         "../compiler/diagnosticInformationMap.generated.ts",
+        "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",
+        "transpile.ts",
         "shims.ts",
         "signatureHelp.ts",
-        "utilities.ts",
-        "jsTyping.ts",
+        "symbolDisplay.ts",
         "formatting/formatting.ts",
         "formatting/formattingContext.ts",
         "formatting/formattingRequestKind.ts",

src/services/types.ts

@@ -0,0 +1,777 @@
+namespace ts {
+    export interface Node {
+        getSourceFile(): SourceFile;
+        getChildCount(sourceFile?: SourceFile): number;
+        getChildAt(index: number, sourceFile?: SourceFile): Node;
+        getChildren(sourceFile?: SourceFile): Node[];
+        getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
+        getFullStart(): number;
+        getEnd(): number;
+        getWidth(sourceFile?: SourceFile): number;
+        getFullWidth(): number;
+        getLeadingTriviaWidth(sourceFile?: SourceFile): number;
+        getFullText(sourceFile?: SourceFile): string;
+        getText(sourceFile?: SourceFile): string;
+        getFirstToken(sourceFile?: SourceFile): Node;
+        getLastToken(sourceFile?: SourceFile): Node;
+    }
+
+    export interface Symbol {
+        getFlags(): SymbolFlags;
+        getName(): string;
+        getDeclarations(): Declaration[];
+        getDocumentationComment(): SymbolDisplayPart[];
+    }
+
+    export interface Type {
+        getFlags(): TypeFlags;
+        getSymbol(): Symbol;
+        getProperties(): Symbol[];
+        getProperty(propertyName: string): Symbol;
+        getApparentProperties(): Symbol[];
+        getCallSignatures(): Signature[];
+        getConstructSignatures(): Signature[];
+        getStringIndexType(): Type;
+        getNumberIndexType(): Type;
+        getBaseTypes(): ObjectType[];
+        getNonNullableType(): Type;
+    }
+
+    export interface Signature {
+        getDeclaration(): SignatureDeclaration;
+        getTypeParameters(): Type[];
+        getParameters(): Symbol[];
+        getReturnType(): Type;
+        getDocumentationComment(): SymbolDisplayPart[];
+    }
+
+    export interface SourceFile {
+        /* @internal */ version: string;
+        /* @internal */ scriptSnapshot: IScriptSnapshot;
+        /* @internal */ nameTable: Map<number>;
+
+        /* @internal */ getNamedDeclarations(): Map<Declaration[]>;
+
+        getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
+        getLineStarts(): number[];
+        getPositionOfLineAndCharacter(line: number, character: number): number;
+        update(newText: string, textChangeRange: TextChangeRange): SourceFile;
+    }
+
+    /**
+     * Represents an immutable snapshot of a script at a specified time.Once acquired, the
+     * snapshot is observably immutable. i.e. the same calls with the same parameters will return
+     * the same values.
+     */
+    export interface IScriptSnapshot {
+        /** Gets a portion of the script snapshot specified by [start, end). */
+        getText(start: number, end: number): string;
+
+        /** Gets the length of this script snapshot. */
+        getLength(): number;
+
+        /**
+         * Gets the TextChangeRange that describe how the text changed between this text and
+         * an older version.  This information is used by the incremental parser to determine
+         * what sections of the script need to be re-parsed.  'undefined' can be returned if the
+         * change range cannot be determined.  However, in that case, incremental parsing will
+         * not happen and the entire document will be re - parsed.
+         */
+        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
+
+        /** Releases all resources held by this script snapshot */
+        dispose?(): void;
+    }
+
+    export namespace ScriptSnapshot {
+        class StringScriptSnapshot implements IScriptSnapshot {
+
+            constructor(private text: string) {
+            }
+
+            public getText(start: number, end: number): string {
+                return this.text.substring(start, end);
+            }
+
+            public getLength(): number {
+                return this.text.length;
+            }
+
+            public getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange {
+                // Text-based snapshots do not support incremental parsing. Return undefined
+                // to signal that to the caller.
+                return undefined;
+            }
+        }
+
+        export function fromString(text: string): IScriptSnapshot {
+            return new StringScriptSnapshot(text);
+        }
+    }
+    export interface PreProcessedFileInfo {
+        referencedFiles: FileReference[];
+        typeReferenceDirectives: FileReference[];
+        importedFiles: FileReference[];
+        ambientExternalModules: string[];
+        isLibFile: boolean;
+    }
+
+    export interface HostCancellationToken {
+        isCancellationRequested(): boolean;
+    }
+
+    //
+    // Public interface of the host of a language service instance.
+    //
+    export interface LanguageServiceHost {
+        getCompilationSettings(): CompilerOptions;
+        getNewLine?(): string;
+        getProjectVersion?(): string;
+        getScriptFileNames(): string[];
+        getScriptKind?(fileName: string): ScriptKind;
+        getScriptVersion(fileName: string): string;
+        getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
+        getLocalizedDiagnosticMessages?(): any;
+        getCancellationToken?(): HostCancellationToken;
+        getCurrentDirectory(): string;
+        getDefaultLibFileName(options: CompilerOptions): string;
+        log?(s: string): void;
+        trace?(s: string): void;
+        error?(s: string): void;
+        useCaseSensitiveFileNames?(): boolean;
+
+        /*
+         * LS host can optionally implement these methods to support completions for module specifiers.
+         * Without these methods, only completions for ambient modules will be provided.
+         */
+        readDirectory?(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
+        readFile?(path: string, encoding?: string): string;
+        fileExists?(path: string): boolean;
+
+        /*
+         * LS host can optionally implement this method if it wants to be completely in charge of module name resolution.
+         * if implementation is omitted then language service will use built-in module resolution logic and get answers to
+         * host specific questions using 'getScriptSnapshot'.
+         */
+        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
+        resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
+        directoryExists?(directoryName: string): boolean;
+
+        /*
+         * getDirectories is also required for full import and type reference completions. Without it defined, certain
+         * completions will not be provided
+         */
+        getDirectories?(directoryName: string): string[];
+    }
+
+    //
+    // Public services of a language service instance associated
+    // with a language service host instance
+    //
+    export interface LanguageService {
+        cleanupSemanticCache(): void;
+
+        getSyntacticDiagnostics(fileName: string): Diagnostic[];
+        getSemanticDiagnostics(fileName: string): Diagnostic[];
+
+        // TODO: Rename this to getProgramDiagnostics to better indicate that these are any
+        // diagnostics present for the program level, and not just 'options' diagnostics.
+        getCompilerOptionsDiagnostics(): Diagnostic[];
+
+        /**
+         * @deprecated Use getEncodedSyntacticClassifications instead.
+         */
+        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+
+        /**
+         * @deprecated Use getEncodedSemanticClassifications instead.
+         */
+        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+
+        // Encoded as triples of [start, length, ClassificationType].
+        getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications;
+        getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications;
+
+        getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
+        getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
+        getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol;
+
+        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
+
+        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;
+
+        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;
+
+        getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;
+
+        getRenameInfo(fileName: string, position: number): RenameInfo;
+        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];
+
+        getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
+        getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
+        getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[];
+
+        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        findReferences(fileName: string, position: number): ReferencedSymbol[];
+        getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[];
+
+        /** @deprecated */
+        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+
+        getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[];
+        getNavigationBarItems(fileName: string): NavigationBarItem[];
+
+        getOutliningSpans(fileName: string): OutliningSpan[];
+        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
+        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
+        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
+
+        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
+        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
+        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
+
+        getDocCommentTemplateAtPosition(fileName: string, position: number): TextInsertion;
+
+        isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
+
+        getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean): EmitOutput;
+
+        getProgram(): Program;
+
+        /* @internal */ getNonBoundSourceFile(fileName: string): SourceFile;
+
+        /**
+         * @internal
+         * @deprecated Use ts.createSourceFile instead.
+         */
+        getSourceFile(fileName: string): SourceFile;
+
+        dispose(): void;
+    }
+
+    export interface Classifications {
+        spans: number[];
+        endOfLineState: EndOfLineState;
+    }
+
+    export interface ClassifiedSpan {
+        textSpan: TextSpan;
+        classificationType: string; // ClassificationTypeNames
+    }
+
+    export interface NavigationBarItem {
+        text: string;
+        kind: string;
+        kindModifiers: string;
+        spans: TextSpan[];
+        childItems: NavigationBarItem[];
+        indent: number;
+        bolded: boolean;
+        grayed: boolean;
+    }
+
+    export interface TodoCommentDescriptor {
+        text: string;
+        priority: number;
+    }
+
+    export interface TodoComment {
+        descriptor: TodoCommentDescriptor;
+        message: string;
+        position: number;
+    }
+
+    export class TextChange {
+        span: TextSpan;
+        newText: string;
+    }
+
+    export interface TextInsertion {
+        newText: string;
+        /** The position in newText the caret should point to after the insertion. */
+        caretOffset: number;
+    }
+
+    export interface RenameLocation {
+        textSpan: TextSpan;
+        fileName: string;
+    }
+
+    export interface ReferenceEntry {
+        textSpan: TextSpan;
+        fileName: string;
+        isWriteAccess: boolean;
+        isDefinition: boolean;
+    }
+
+    export interface ImplementationLocation {
+        textSpan: TextSpan;
+        fileName: string;
+    }
+
+    export interface DocumentHighlights {
+        fileName: string;
+        highlightSpans: HighlightSpan[];
+    }
+
+    export namespace HighlightSpanKind {
+        export const none = "none";
+        export const definition = "definition";
+        export const reference = "reference";
+        export const writtenReference = "writtenReference";
+    }
+
+    export interface HighlightSpan {
+        fileName?: string;
+        textSpan: TextSpan;
+        kind: string;
+    }
+
+    export interface NavigateToItem {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+        matchKind: string;
+        isCaseSensitive: boolean;
+        fileName: string;
+        textSpan: TextSpan;
+        containerName: string;
+        containerKind: string;
+    }
+
+    export enum IndentStyle {
+        None = 0,
+        Block = 1,
+        Smart = 2,
+    }
+
+    /* @deprecated - consider using EditorSettings instead */
+    export interface EditorOptions {
+        BaseIndentSize?: number;
+        IndentSize: number;
+        TabSize: number;
+        NewLineCharacter: string;
+        ConvertTabsToSpaces: boolean;
+        IndentStyle: IndentStyle;
+    }
+
+    export interface EditorSettings {
+        baseIndentSize?: number;
+        indentSize: number;
+        tabSize: number;
+        newLineCharacter: string;
+        convertTabsToSpaces: boolean;
+        indentStyle: IndentStyle;
+    }
+
+    /* @deprecated - consider using FormatCodeSettings instead */
+    export interface FormatCodeOptions extends EditorOptions {
+        InsertSpaceAfterCommaDelimiter: boolean;
+        InsertSpaceAfterSemicolonInForStatements: boolean;
+        InsertSpaceBeforeAndAfterBinaryOperators: boolean;
+        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
+        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
+        InsertSpaceAfterTypeAssertion?: boolean;
+        PlaceOpenBraceOnNewLineForFunctions: boolean;
+        PlaceOpenBraceOnNewLineForControlBlocks: boolean;
+    }
+
+    export interface FormatCodeSettings extends EditorSettings {
+        insertSpaceAfterCommaDelimiter: boolean;
+        insertSpaceAfterSemicolonInForStatements: boolean;
+        insertSpaceBeforeAndAfterBinaryOperators: boolean;
+        insertSpaceAfterKeywordsInControlFlowStatements: boolean;
+        insertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
+        insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: boolean;
+        insertSpaceAfterTypeAssertion?: boolean;
+        placeOpenBraceOnNewLineForFunctions: boolean;
+        placeOpenBraceOnNewLineForControlBlocks: boolean;
+    }
+
+    export interface DefinitionInfo {
+        fileName: string;
+        textSpan: TextSpan;
+        kind: string;
+        name: string;
+        containerKind: string;
+        containerName: string;
+    }
+
+    export interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
+        displayParts: SymbolDisplayPart[];
+    }
+
+    export interface ReferencedSymbol {
+        definition: ReferencedSymbolDefinitionInfo;
+        references: ReferenceEntry[];
+    }
+
+    export enum SymbolDisplayPartKind {
+        aliasName,
+        className,
+        enumName,
+        fieldName,
+        interfaceName,
+        keyword,
+        lineBreak,
+        numericLiteral,
+        stringLiteral,
+        localName,
+        methodName,
+        moduleName,
+        operator,
+        parameterName,
+        propertyName,
+        punctuation,
+        space,
+        text,
+        typeParameterName,
+        enumMemberName,
+        functionName,
+        regularExpressionLiteral,
+    }
+
+    export interface SymbolDisplayPart {
+        text: string;
+        kind: string;
+    }
+
+    export interface QuickInfo {
+        kind: string;
+        kindModifiers: string;
+        textSpan: TextSpan;
+        displayParts: SymbolDisplayPart[];
+        documentation: SymbolDisplayPart[];
+    }
+
+    export interface RenameInfo {
+        canRename: boolean;
+        localizedErrorMessage: string;
+        displayName: string;
+        fullDisplayName: string;
+        kind: string;
+        kindModifiers: string;
+        triggerSpan: TextSpan;
+    }
+
+    export interface SignatureHelpParameter {
+        name: string;
+        documentation: SymbolDisplayPart[];
+        displayParts: SymbolDisplayPart[];
+        isOptional: boolean;
+    }
+
+    /**
+     * Represents a single signature to show in signature help.
+     * The id is used for subsequent calls into the language service to ask questions about the
+     * signature help item in the context of any documents that have been updated.  i.e. after
+     * an edit has happened, while signature help is still active, the host can ask important
+     * questions like 'what parameter is the user currently contained within?'.
+     */
+    export interface SignatureHelpItem {
+        isVariadic: boolean;
+        prefixDisplayParts: SymbolDisplayPart[];
+        suffixDisplayParts: SymbolDisplayPart[];
+        separatorDisplayParts: SymbolDisplayPart[];
+        parameters: SignatureHelpParameter[];
+        documentation: SymbolDisplayPart[];
+    }
+
+    /**
+     * Represents a set of signature help items, and the preferred item that should be selected.
+     */
+    export interface SignatureHelpItems {
+        items: SignatureHelpItem[];
+        applicableSpan: TextSpan;
+        selectedItemIndex: number;
+        argumentIndex: number;
+        argumentCount: number;
+    }
+
+    export interface CompletionInfo {
+        isMemberCompletion: boolean;
+        isNewIdentifierLocation: boolean;  // true when the current location also allows for a new identifier
+        entries: CompletionEntry[];
+    }
+
+    export interface CompletionEntry {
+        name: string;
+        kind: string;            // see ScriptElementKind
+        kindModifiers: string;   // see ScriptElementKindModifier, comma separated
+        sortText: string;
+        /**
+          * An optional span that indicates the text to be replaced by this completion item. It will be
+          * set if the required span differs from the one generated by the default replacement behavior and should
+          * be used in that case
+          */
+        replacementSpan?: TextSpan;
+    }
+
+    export interface CompletionEntryDetails {
+        name: string;
+        kind: string;            // see ScriptElementKind
+        kindModifiers: string;   // see ScriptElementKindModifier, comma separated
+        displayParts: SymbolDisplayPart[];
+        documentation: SymbolDisplayPart[];
+    }
+
+    export interface OutliningSpan {
+        /** The span of the document to actually collapse. */
+        textSpan: TextSpan;
+
+        /** The span of the document to display when the user hovers over the collapsed span. */
+        hintSpan: TextSpan;
+
+        /** The text to display in the editor for the collapsed region. */
+        bannerText: string;
+
+        /**
+          * Whether or not this region should be automatically collapsed when
+          * the 'Collapse to Definitions' command is invoked.
+          */
+        autoCollapse: boolean;
+    }
+
+    export interface EmitOutput {
+        outputFiles: OutputFile[];
+        emitSkipped: boolean;
+    }
+
+    export const enum OutputFileType {
+        JavaScript,
+        SourceMap,
+        Declaration
+    }
+
+    export interface OutputFile {
+        name: string;
+        writeByteOrderMark: boolean;
+        text: string;
+    }
+
+    export const enum EndOfLineState {
+        None,
+        InMultiLineCommentTrivia,
+        InSingleQuoteStringLiteral,
+        InDoubleQuoteStringLiteral,
+        InTemplateHeadOrNoSubstitutionTemplate,
+        InTemplateMiddleOrTail,
+        InTemplateSubstitutionPosition,
+    }
+
+    export enum TokenClass {
+        Punctuation,
+        Keyword,
+        Operator,
+        Comment,
+        Whitespace,
+        Identifier,
+        NumberLiteral,
+        StringLiteral,
+        RegExpLiteral,
+    }
+
+    export interface ClassificationResult {
+        finalLexState: EndOfLineState;
+        entries: ClassificationInfo[];
+    }
+
+    export interface ClassificationInfo {
+        length: number;
+        classification: TokenClass;
+    }
+
+    export interface Classifier {
+        /**
+         * Gives lexical classifications of tokens on a line without any syntactic context.
+         * For instance, a token consisting of the text 'string' can be either an identifier
+         * named 'string' or the keyword 'string', however, because this classifier is not aware,
+         * it relies on certain heuristics to give acceptable results. For classifications where
+         * speed trumps accuracy, this function is preferable; however, for true accuracy, the
+         * syntactic classifier is ideal. In fact, in certain editing scenarios, combining the
+         * lexical, syntactic, and semantic classifiers may issue the best user experience.
+         *
+         * @param text                      The text of a line to classify.
+         * @param lexState                  The state of the lexical classifier at the end of the previous line.
+         * @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier.
+         *                                  If there is no syntactic classifier (syntacticClassifierAbsent=true),
+         *                                  certain heuristics may be used in its place; however, if there is a
+         *                                  syntactic classifier (syntacticClassifierAbsent=false), certain
+         *                                  classifications which may be incorrectly categorized will be given
+         *                                  back as Identifiers in order to allow the syntactic classifier to
+         *                                  subsume the classification.
+         * @deprecated Use getLexicalClassifications instead.
+         */
+        getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult;
+        getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications;
+    }
+
+    // TODO: move these to enums
+    export namespace ScriptElementKind {
+        export const unknown = "";
+        export const warning = "warning";
+
+        /** predefined type (void) or keyword (class) */
+        export const keyword = "keyword";
+
+        /** top level script node */
+        export const scriptElement = "script";
+
+        /** module foo {} */
+        export const moduleElement = "module";
+
+        /** class X {} */
+        export const classElement = "class";
+
+        /** var x = class X {} */
+        export const localClassElement = "local class";
+
+        /** interface Y {} */
+        export const interfaceElement = "interface";
+
+        /** type T = ... */
+        export const typeElement = "type";
+
+        /** enum E */
+        export const enumElement = "enum";
+        // TODO: GH#9983
+        export const enumMemberElement = "const";
+
+        /**
+         * Inside module and script only
+         * const v = ..
+         */
+        export const variableElement = "var";
+
+        /** Inside function */
+        export const localVariableElement = "local var";
+
+        /**
+         * Inside module and script only
+         * function f() { }
+         */
+        export const functionElement = "function";
+
+        /** Inside function */
+        export const localFunctionElement = "local function";
+
+        /** class X { [public|private]* foo() {} } */
+        export const memberFunctionElement = "method";
+
+        /** class X { [public|private]* [get|set] foo:number; } */
+        export const memberGetAccessorElement = "getter";
+        export const memberSetAccessorElement = "setter";
+
+        /**
+         * class X { [public|private]* foo:number; }
+         * interface Y { foo:number; }
+         */
+        export const memberVariableElement = "property";
+
+        /** class X { constructor() { } } */
+        export const constructorImplementationElement = "constructor";
+
+        /** interface Y { ():number; } */
+        export const callSignatureElement = "call";
+
+        /** interface Y { []:number; } */
+        export const indexSignatureElement = "index";
+
+        /** interface Y { new():Y; } */
+        export const constructSignatureElement = "construct";
+
+        /** function foo(*Y*: string) */
+        export const parameterElement = "parameter";
+
+        export const typeParameterElement = "type parameter";
+
+        export const primitiveType = "primitive type";
+
+        export const label = "label";
+
+        export const alias = "alias";
+
+        export const constElement = "const";
+
+        export const letElement = "let";
+
+        export const directory = "directory";
+
+        export const externalModuleName = "external module name";
+    }
+
+    export namespace ScriptElementKindModifier {
+        export const none = "";
+        export const publicMemberModifier = "public";
+        export const privateMemberModifier = "private";
+        export const protectedMemberModifier = "protected";
+        export const exportedModifier = "export";
+        export const ambientModifier = "declare";
+        export const staticModifier = "static";
+        export const abstractModifier = "abstract";
+    }
+
+    export class ClassificationTypeNames {
+        public static comment = "comment";
+        public static identifier = "identifier";
+        public static keyword = "keyword";
+        public static numericLiteral = "number";
+        public static operator = "operator";
+        public static stringLiteral = "string";
+        public static whiteSpace = "whitespace";
+        public static text = "text";
+
+        public static punctuation = "punctuation";
+
+        public static className = "class name";
+        public static enumName = "enum name";
+        public static interfaceName = "interface name";
+        public static moduleName = "module name";
+        public static typeParameterName = "type parameter name";
+        public static typeAliasName = "type alias name";
+        public static parameterName = "parameter name";
+        public static docCommentTagName = "doc comment tag name";
+        public static jsxOpenTagName = "jsx open tag name";
+        public static jsxCloseTagName = "jsx close tag name";
+        public static jsxSelfClosingTagName = "jsx self closing tag name";
+        public static jsxAttribute = "jsx attribute";
+        public static jsxText = "jsx text";
+        public static jsxAttributeStringLiteralValue = "jsx attribute string literal value";
+    }
+
+    export const enum ClassificationType {
+        comment = 1,
+        identifier = 2,
+        keyword = 3,
+        numericLiteral = 4,
+        operator = 5,
+        stringLiteral = 6,
+        regularExpressionLiteral = 7,
+        whiteSpace = 8,
+        text = 9,
+        punctuation = 10,
+        className = 11,
+        enumName = 12,
+        interfaceName = 13,
+        moduleName = 14,
+        typeParameterName = 15,
+        typeAliasName = 16,
+        parameterName = 17,
+        docCommentTagName = 18,
+        jsxOpenTagName = 19,
+        jsxCloseTagName = 20,
+        jsxSelfClosingTagName = 21,
+        jsxAttribute = 22,
+        jsxText = 23,
+        jsxAttributeStringLiteralValue = 24,
+    }
+}

src/services/utilities.ts

@@ -1,6 +1,387 @@
 // These utilities are common to multiple language service features.
 /* @internal */
 namespace ts {
+    export const scanner: Scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
+    export const emptyArray: any[] = [];
+
+    export const enum SemanticMeaning {
+        None = 0x0,
+        Value = 0x1,
+        Type = 0x2,
+        Namespace = 0x4,
+        All = Value | Type | Namespace
+    }
+
+    export function getMeaningFromDeclaration(node: Node): SemanticMeaning {
+        switch (node.kind) {
+            case SyntaxKind.Parameter:
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.BindingElement:
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
+            case SyntaxKind.EnumMember:
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+            case SyntaxKind.Constructor:
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.CatchClause:
+                return SemanticMeaning.Value;
+
+            case SyntaxKind.TypeParameter:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind.TypeLiteral:
+                return SemanticMeaning.Type;
+
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.EnumDeclaration:
+                return SemanticMeaning.Value | SemanticMeaning.Type;
+
+            case SyntaxKind.ModuleDeclaration:
+                if (isAmbientModule(<ModuleDeclaration>node)) {
+                    return SemanticMeaning.Namespace | SemanticMeaning.Value;
+                }
+                else if (getModuleInstanceState(node) === ModuleInstanceState.Instantiated) {
+                    return SemanticMeaning.Namespace | SemanticMeaning.Value;
+                }
+                else {
+                    return SemanticMeaning.Namespace;
+                }
+
+            case SyntaxKind.NamedImports:
+            case SyntaxKind.ImportSpecifier:
+            case SyntaxKind.ImportEqualsDeclaration:
+            case SyntaxKind.ImportDeclaration:
+            case SyntaxKind.ExportAssignment:
+            case SyntaxKind.ExportDeclaration:
+                return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+
+            // An external module can be a Value
+            case SyntaxKind.SourceFile:
+                return SemanticMeaning.Namespace | SemanticMeaning.Value;
+        }
+
+        return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+    }
+
+    export function getMeaningFromLocation(node: Node): SemanticMeaning {
+        if (node.parent.kind === SyntaxKind.ExportAssignment) {
+            return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+        }
+        else if (isInRightSideOfImport(node)) {
+            return getMeaningFromRightHandSideOfImportEquals(node);
+        }
+        else if (isDeclarationName(node)) {
+            return getMeaningFromDeclaration(node.parent);
+        }
+        else if (isTypeReference(node)) {
+            return SemanticMeaning.Type;
+        }
+        else if (isNamespaceReference(node)) {
+            return SemanticMeaning.Namespace;
+        }
+        else {
+            return SemanticMeaning.Value;
+        }
+    }
+
+    function getMeaningFromRightHandSideOfImportEquals(node: Node) {
+        Debug.assert(node.kind === SyntaxKind.Identifier);
+
+        //     import a = |b|; // Namespace
+        //     import a = |b.c|; // Value, type, namespace
+        //     import a = |b.c|.d; // Namespace
+
+        if (node.parent.kind === SyntaxKind.QualifiedName &&
+            (<QualifiedName>node.parent).right === node &&
+            node.parent.parent.kind === SyntaxKind.ImportEqualsDeclaration) {
+            return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+        }
+        return SemanticMeaning.Namespace;
+    }
+
+    function isInRightSideOfImport(node: Node) {
+        while (node.parent.kind === SyntaxKind.QualifiedName) {
+            node = node.parent;
+        }
+        return isInternalModuleImportEqualsDeclaration(node.parent) && (<ImportEqualsDeclaration>node.parent).moduleReference === node;
+    }
+
+    function isNamespaceReference(node: Node): boolean {
+        return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node);
+    }
+
+    function isQualifiedNameNamespaceReference(node: Node): boolean {
+        let root = node;
+        let isLastClause = true;
+        if (root.parent.kind === SyntaxKind.QualifiedName) {
+            while (root.parent && root.parent.kind === SyntaxKind.QualifiedName) {
+                root = root.parent;
+            }
+
+            isLastClause = (<QualifiedName>root).right === node;
+        }
+
+        return root.parent.kind === SyntaxKind.TypeReference && !isLastClause;
+    }
+
+    function isPropertyAccessNamespaceReference(node: Node): boolean {
+        let root = node;
+        let isLastClause = true;
+        if (root.parent.kind === SyntaxKind.PropertyAccessExpression) {
+            while (root.parent && root.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                root = root.parent;
+            }
+
+            isLastClause = (<PropertyAccessExpression>root).name === node;
+        }
+
+        if (!isLastClause && root.parent.kind === SyntaxKind.ExpressionWithTypeArguments && root.parent.parent.kind === SyntaxKind.HeritageClause) {
+            const decl = root.parent.parent.parent;
+            return (decl.kind === SyntaxKind.ClassDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ImplementsKeyword) ||
+                (decl.kind === SyntaxKind.InterfaceDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ExtendsKeyword);
+        }
+
+        return false;
+    }
+
+    function isTypeReference(node: Node): boolean {
+        if (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
+            node = node.parent;
+        }
+
+        return node.parent.kind === SyntaxKind.TypeReference ||
+            (node.parent.kind === SyntaxKind.ExpressionWithTypeArguments && !isExpressionWithTypeArgumentsInClassExtendsClause(<ExpressionWithTypeArguments>node.parent)) ||
+            (node.kind === SyntaxKind.ThisKeyword && !isPartOfExpression(node)) ||
+            node.kind === SyntaxKind.ThisType;
+    }
+
+    export function isCallExpressionTarget(node: Node): boolean {
+        return isCallOrNewExpressionTarget(node, SyntaxKind.CallExpression);
+    }
+
+    export function isNewExpressionTarget(node: Node): boolean {
+        return isCallOrNewExpressionTarget(node, SyntaxKind.NewExpression);
+    }
+
+    function isCallOrNewExpressionTarget(node: Node, kind: SyntaxKind) {
+        const target = climbPastPropertyAccess(node);
+        return target && target.parent && target.parent.kind === kind && (<CallExpression>target.parent).expression === target;
+    }
+
+    export function climbPastPropertyAccess(node: Node) {
+        return isRightSideOfPropertyAccess(node) ? node.parent : node;
+    }
+
+    export function getTargetLabel(referenceNode: Node, labelName: string): Identifier {
+        while (referenceNode) {
+            if (referenceNode.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>referenceNode).label.text === labelName) {
+                return (<LabeledStatement>referenceNode).label;
+            }
+            referenceNode = referenceNode.parent;
+        }
+        return undefined;
+    }
+
+    export function isJumpStatementTarget(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            (node.parent.kind === SyntaxKind.BreakStatement || node.parent.kind === SyntaxKind.ContinueStatement) &&
+            (<BreakOrContinueStatement>node.parent).label === node;
+    }
+
+    function isLabelOfLabeledStatement(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            node.parent.kind === SyntaxKind.LabeledStatement &&
+            (<LabeledStatement>node.parent).label === node;
+    }
+
+    export function isLabelName(node: Node): boolean {
+        return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node);
+    }
+
+    export function isRightSideOfQualifiedName(node: Node) {
+        return node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node;
+    }
+
+    export function isRightSideOfPropertyAccess(node: Node) {
+        return node && node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node;
+    }
+
+    export function isNameOfModuleDeclaration(node: Node) {
+        return node.parent.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>node.parent).name === node;
+    }
+
+    export function isNameOfFunctionDeclaration(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            isFunctionLike(node.parent) && (<FunctionLikeDeclaration>node.parent).name === node;
+    }
+
+    export function isLiteralNameOfPropertyDeclarationOrIndexAccess(node: Node): boolean {
+        if (node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral) {
+            switch (node.parent.kind) {
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.PropertySignature:
+                case SyntaxKind.PropertyAssignment:
+                case SyntaxKind.EnumMember:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.ModuleDeclaration:
+                    return (<Declaration>node.parent).name === node;
+                case SyntaxKind.ElementAccessExpression:
+                    return (<ElementAccessExpression>node.parent).argumentExpression === node;
+                case SyntaxKind.ComputedPropertyName:
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    export function isExpressionOfExternalModuleImportEqualsDeclaration(node: Node) {
+        return isExternalModuleImportEqualsDeclaration(node.parent.parent) &&
+            getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node;
+    }
+
+    /** Returns true if the position is within a comment */
+    export function isInsideComment(sourceFile: SourceFile, token: Node, position: number): boolean {
+        // The position has to be: 1. in the leading trivia (before token.getStart()), and 2. within a comment
+        return position <= token.getStart(sourceFile) &&
+            (isInsideCommentRange(getTrailingCommentRanges(sourceFile.text, token.getFullStart())) ||
+                isInsideCommentRange(getLeadingCommentRanges(sourceFile.text, token.getFullStart())));
+
+        function isInsideCommentRange(comments: CommentRange[]): boolean {
+            return forEach(comments, comment => {
+                // either we are 1. completely inside the comment, or 2. at the end of the comment
+                if (comment.pos < position && position < comment.end) {
+                    return true;
+                }
+                else if (position === comment.end) {
+                    const text = sourceFile.text;
+                    const width = comment.end - comment.pos;
+                    // is single line comment or just /*
+                    if (width <= 2 || text.charCodeAt(comment.pos + 1) === CharacterCodes.slash) {
+                        return true;
+                    }
+                    else {
+                        // is unterminated multi-line comment
+                        return !(text.charCodeAt(comment.end - 1) === CharacterCodes.slash &&
+                            text.charCodeAt(comment.end - 2) === CharacterCodes.asterisk);
+                    }
+                }
+                return false;
+            });
+        }
+    }
+
+    export function getContainerNode(node: Node): Declaration {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case SyntaxKind.SourceFile:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                    return <Declaration>node;
+            }
+        }
+    }
+
+    export function getNodeKind(node: Node): string {
+        switch (node.kind) {
+            case SyntaxKind.SourceFile:
+                return isExternalModule(<SourceFile>node) ? ScriptElementKind.moduleElement : ScriptElementKind.scriptElement;
+            case SyntaxKind.ModuleDeclaration:
+                return ScriptElementKind.moduleElement;
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
+                return ScriptElementKind.classElement;
+            case SyntaxKind.InterfaceDeclaration: return ScriptElementKind.interfaceElement;
+            case SyntaxKind.TypeAliasDeclaration: return ScriptElementKind.typeElement;
+            case SyntaxKind.EnumDeclaration: return ScriptElementKind.enumElement;
+            case SyntaxKind.VariableDeclaration:
+                return getKindOfVariableDeclaration(<VariableDeclaration>node);
+            case SyntaxKind.BindingElement:
+                return getKindOfVariableDeclaration(<VariableDeclaration>getRootDeclaration(node));
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.FunctionExpression:
+                return ScriptElementKind.functionElement;
+            case SyntaxKind.GetAccessor: return ScriptElementKind.memberGetAccessorElement;
+            case SyntaxKind.SetAccessor: return ScriptElementKind.memberSetAccessorElement;
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+                return ScriptElementKind.memberFunctionElement;
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+                return ScriptElementKind.memberVariableElement;
+            case SyntaxKind.IndexSignature: return ScriptElementKind.indexSignatureElement;
+            case SyntaxKind.ConstructSignature: return ScriptElementKind.constructSignatureElement;
+            case SyntaxKind.CallSignature: return ScriptElementKind.callSignatureElement;
+            case SyntaxKind.Constructor: return ScriptElementKind.constructorImplementationElement;
+            case SyntaxKind.TypeParameter: return ScriptElementKind.typeParameterElement;
+            case SyntaxKind.EnumMember: return ScriptElementKind.enumMemberElement;
+            case SyntaxKind.Parameter: return hasModifier(node, ModifierFlags.ParameterPropertyModifier) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
+            case SyntaxKind.ImportEqualsDeclaration:
+            case SyntaxKind.ImportSpecifier:
+            case SyntaxKind.ImportClause:
+            case SyntaxKind.ExportSpecifier:
+            case SyntaxKind.NamespaceImport:
+                return ScriptElementKind.alias;
+            case SyntaxKind.JSDocTypedefTag:
+                return ScriptElementKind.typeElement;
+            default:
+                return ScriptElementKind.unknown;
+        }
+
+        function getKindOfVariableDeclaration(v: VariableDeclaration): string {
+            return isConst(v)
+                ? ScriptElementKind.constElement
+                : isLet(v)
+                    ? ScriptElementKind.letElement
+                    : ScriptElementKind.variableElement;
+        }
+    }
+
+    export function getStringLiteralTypeForNode(node: StringLiteral | LiteralTypeNode, typeChecker: TypeChecker): LiteralType {
+        const searchNode = node.parent.kind === SyntaxKind.LiteralType ? <LiteralTypeNode>node.parent : node;
+        const type = typeChecker.getTypeAtLocation(searchNode);
+        if (type && type.flags & TypeFlags.StringLiteral) {
+            return <LiteralType>type;
+        }
+        return undefined;
+    }
+
+    export function isThis(node: Node): boolean {
+        switch (node.kind) {
+            case SyntaxKind.ThisKeyword:
+            // case SyntaxKind.ThisType: TODO: GH#9267
+                return true;
+            case SyntaxKind.Identifier:
+                // 'this' as a parameter
+                return (node as Identifier).originalKeywordKind === SyntaxKind.ThisKeyword && node.parent.kind === SyntaxKind.Parameter;
+            default:
+                return false;
+        }
+    }
+
     // Matches the beginning of a triple slash directive
     const tripleSlashDirectivePrefixRegex = /^\/\/\/\s*</;
 
@@ -572,9 +953,11 @@ namespace ts {
         if (node) {
             if (node.jsDocComments) {
                 for (const jsDocComment of node.jsDocComments) {
-                    for (const tag of jsDocComment.tags) {
-                        if (tag.pos <= position && position <= tag.end) {
-                            return tag;
+                    if (jsDocComment.tags) {
+                        for (const tag of jsDocComment.tags) {
+                            if (tag.pos <= position && position <= tag.end) {
+                                return tag;
+                            }
                         }
                     }
                 }
@@ -591,15 +974,15 @@ namespace ts {
     }
 
     export function getNodeModifiers(node: Node): string {
-        const flags = getCombinedNodeFlags(node);
+        const flags = getCombinedModifierFlags(node);
         const result: string[] = [];
 
-        if (flags & NodeFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier);
-        if (flags & NodeFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier);
-        if (flags & NodeFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier);
-        if (flags & NodeFlags.Static) result.push(ScriptElementKindModifier.staticModifier);
-        if (flags & NodeFlags.Abstract) result.push(ScriptElementKindModifier.abstractModifier);
-        if (flags & NodeFlags.Export) result.push(ScriptElementKindModifier.exportedModifier);
+        if (flags & ModifierFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier);
+        if (flags & ModifierFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier);
+        if (flags & ModifierFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier);
+        if (flags & ModifierFlags.Static) result.push(ScriptElementKindModifier.staticModifier);
+        if (flags & ModifierFlags.Abstract) result.push(ScriptElementKindModifier.abstractModifier);
+        if (flags & ModifierFlags.Export) result.push(ScriptElementKindModifier.exportedModifier);
         if (isInAmbientContext(node)) result.push(ScriptElementKindModifier.ambientModifier);
 
         return result.length > 0 ? result.join(",") : ScriptElementKindModifier.none;
@@ -975,4 +1358,4 @@ namespace ts {
             diagnostics: error ? concatenate(diagnostics, [error]) : diagnostics
         };
     }
-}
+}