Merge branch 'master' into modify-extends

src/compiler/binder.ts

@@ -283,8 +283,8 @@ namespace ts {
                     // Parameters with names are handled at the top of this function.  Parameters
                     // without names can only come from JSDocFunctionTypes.
                     Debug.assert(node.parent.kind === SyntaxKind.JSDocFunctionType);
-                    let functionType = <JSDocFunctionType>node.parent;
-                    let index = indexOf(functionType.parameters, node);
+                    const functionType = <JSDocFunctionType>node.parent;
+                    const index = indexOf(functionType.parameters, node);
                     return "arg" + index;
                 case SyntaxKind.JSDocTypedefTag:
                     const parentNode = node.parent && node.parent.parent;
@@ -3133,6 +3133,7 @@ namespace ts {
             case SyntaxKind.TaggedTemplateExpression:
             case SyntaxKind.ShorthandPropertyAssignment:
             case SyntaxKind.StaticKeyword:
+            case SyntaxKind.MetaProperty:
                 // These nodes are ES6 syntax.
                 transformFlags |= TransformFlags.AssertES2015;
                 break;

src/compiler/commandLineParser.ts

@@ -572,7 +572,6 @@ namespace ts {
         }
     }
 
-    /* @internal */
     export function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine {
         const options: CompilerOptions = {};
         const fileNames: string[] = [];
@@ -621,7 +620,7 @@ namespace ts {
                                     break;
                                 case "boolean":
                                     // boolean flag has optional value true, false, others
-                                    let optValue = args[i];
+                                    const optValue = args[i];
                                     options[opt.name] = optValue !== "false";
                                     // consume next argument as boolean flag value
                                     if (optValue === "false" || optValue === "true") {
@@ -779,7 +778,7 @@ namespace ts {
                             break;
                         default:
                             const value = options[name];
-                            let optionDefinition = optionsNameMap[name.toLowerCase()];
+                            const optionDefinition = optionsNameMap[name.toLowerCase()];
                             if (optionDefinition) {
                                 const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
                                 if (!customTypeMap) {
@@ -841,8 +840,9 @@ 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, resolutionStack: Path[] = []): ParsedCommandLine {
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions: CompilerOptions = {}, configFileName?: string, resolutionStack: Path[] = [], extraFileExtensions: FileExtensionInfo[] = []): ParsedCommandLine {
         const errors: Diagnostic[] = [];
+        basePath = normalizeSlashes(basePath);
         const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
         const resolvedPath = toPath(configFileName || "", basePath, getCanonicalFileName);
         if (resolutionStack.indexOf(resolvedPath) >= 0) {
@@ -981,7 +981,7 @@ namespace ts {
                 includeSpecs = ["**/*"];
             }
 
-            const result = matchFileNames(fileNames, includeSpecs, excludeSpecs, basePath, options, host, errors);
+            const result = matchFileNames(fileNames, includeSpecs, excludeSpecs, basePath, options, host, errors, extraFileExtensions);
 
             if (result.fileNames.length === 0 && !hasProperty(json, "files") && resolutionStack.length === 0) {
                 errors.push(
@@ -1185,7 +1185,7 @@ namespace ts {
      * @param host The host used to resolve files and directories.
      * @param errors An array for diagnostic reporting.
      */
-    function matchFileNames(fileNames: string[], include: string[], exclude: string[], basePath: string, options: CompilerOptions, host: ParseConfigHost, errors: Diagnostic[]): ExpandResult {
+    function matchFileNames(fileNames: string[], include: string[], exclude: string[], basePath: string, options: CompilerOptions, host: ParseConfigHost, errors: Diagnostic[], extraFileExtensions: FileExtensionInfo[]): ExpandResult {
         basePath = normalizePath(basePath);
 
         // The exclude spec list is converted into a regular expression, which allows us to quickly
@@ -1219,7 +1219,7 @@ namespace ts {
 
         // Rather than requery this for each file and filespec, we query the supported extensions
         // once and store it on the expansion context.
-        const supportedExtensions = getSupportedExtensions(options);
+        const supportedExtensions = getSupportedExtensions(options, extraFileExtensions);
 
         // Literal files are always included verbatim. An "include" or "exclude" specification cannot
         // remove a literal file.

src/compiler/comments.ts

@@ -156,6 +156,9 @@ namespace ts {
 
             if (!skipTrailingComments) {
                 emitLeadingComments(detachedRange.end, /*isEmittedNode*/ true);
+                if (hasWrittenComment && !writer.isAtStartOfLine()) {
+                    writer.writeLine();
+                }
             }
 
             if (extendedDiagnostics) {

src/compiler/core.ts

@@ -119,7 +119,7 @@ namespace ts {
      */
     export function forEach<T, U>(array: T[] | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {
         if (array) {
-            for (let i = 0, len = array.length; i < len; i++) {
+            for (let i = 0; i < array.length; i++) {
                 const result = callback(array[i], i);
                 if (result) {
                     return result;
@@ -143,7 +143,7 @@ namespace ts {
      */
     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++) {
+            for (let i = 0; i < array.length; i++) {
                 if (!callback(array[i], i)) {
                     return false;
                 }
@@ -155,7 +155,7 @@ namespace ts {
 
     /** 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++) {
+        for (let i = 0; i < array.length; i++) {
             const value = array[i];
             if (predicate(value, i)) {
                 return value;
@@ -169,7 +169,7 @@ namespace ts {
      * This is like `forEach`, but never returns undefined.
      */
     export function findMap<T, U>(array: T[], callback: (element: T, index: number) => U | undefined): U {
-        for (let i = 0, len = array.length; i < len; i++) {
+        for (let i = 0; i < array.length; i++) {
             const result = callback(array[i], i);
             if (result) {
                 return result;
@@ -191,7 +191,7 @@ namespace ts {
 
     export function indexOf<T>(array: T[], value: T): number {
         if (array) {
-            for (let i = 0, len = array.length; i < len; i++) {
+            for (let i = 0; i < array.length; i++) {
                 if (array[i] === value) {
                     return i;
                 }
@@ -201,7 +201,7 @@ namespace ts {
     }
 
     export function indexOfAnyCharCode(text: string, charCodes: number[], start?: number): number {
-        for (let i = start || 0, len = text.length; i < len; i++) {
+        for (let i = start || 0; i < text.length; i++) {
             if (contains(charCodes, text.charCodeAt(i))) {
                 return i;
             }
@@ -863,24 +863,6 @@ namespace ts {
         return result;
     }
 
-    /**
-     * Reduce the properties defined on a map-like (but not from its prototype chain).
-     *
-     * NOTE: This is intended for use with MapLike<T> objects. For Map<T> objects, use
-     *       reduceProperties instead as it offers better performance.
-     *
-     * @param map The map-like to reduce
-     * @param callback An aggregation function that is called for each entry in the map
-     * @param initial The initial value for the reduction.
-     */
-    export function reduceOwnProperties<T, U>(map: MapLike<T>, callback: (aggregate: U, value: T, key: string) => U, initial: U): U {
-        let result = initial;
-        for (const key in map) if (hasOwnProperty.call(map, key)) {
-            result = callback(result, map[key], String(key));
-        }
-        return result;
-    }
-
     /**
      * Performs a shallow equality comparison of the contents of two map-likes.
      *
@@ -1078,7 +1060,7 @@ namespace ts {
         }
     }
 
-    function formatStringFromArgs(text: string, args: { [index: number]: string; }, baseIndex?: number): string {
+    export function formatStringFromArgs(text: string, args: { [index: number]: string; }, baseIndex?: number): string {
         baseIndex = baseIndex || 0;
 
         return text.replace(/{(\d+)}/g, (_match, index?) => args[+index + baseIndex]);
@@ -1942,8 +1924,18 @@ namespace ts {
     export const supportedJavascriptExtensions = [".js", ".jsx"];
     const allSupportedExtensions = supportedTypeScriptExtensions.concat(supportedJavascriptExtensions);
 
-    export function getSupportedExtensions(options?: CompilerOptions): string[] {
-        return options && options.allowJs ? allSupportedExtensions : supportedTypeScriptExtensions;
+    export function getSupportedExtensions(options?: CompilerOptions, extraFileExtensions?: FileExtensionInfo[]): string[] {
+        const needAllExtensions = options && options.allowJs;
+        if (!extraFileExtensions || extraFileExtensions.length === 0) {
+            return needAllExtensions ? allSupportedExtensions : supportedTypeScriptExtensions;
+        }
+        const extensions = (needAllExtensions ? allSupportedExtensions : supportedTypeScriptExtensions).slice(0);
+        for (const extInfo of extraFileExtensions) {
+            if (needAllExtensions || extInfo.scriptKind === ScriptKind.TS) {
+                extensions.push(extInfo.extension);
+            }
+        }
+        return extensions;
     }
 
     export function hasJavaScriptFileExtension(fileName: string) {
@@ -1954,10 +1946,10 @@ namespace ts {
         return forEach(supportedTypeScriptExtensions, extension => fileExtensionIs(fileName, extension));
     }
 
-    export function isSupportedSourceFileName(fileName: string, compilerOptions?: CompilerOptions) {
+    export function isSupportedSourceFileName(fileName: string, compilerOptions?: CompilerOptions, extraFileExtensions?: FileExtensionInfo[]) {
         if (!fileName) { return false; }
 
-        for (const extension of getSupportedExtensions(compilerOptions)) {
+        for (const extension of getSupportedExtensions(compilerOptions, extraFileExtensions)) {
             if (fileExtensionIs(fileName, extension)) {
                 return true;
             }

src/compiler/diagnosticMessages.json

@@ -227,7 +227,7 @@
         "category": "Error",
         "code": 1084
     },
-    "Octal literals are not available when targeting ECMAScript 5 and higher.": {
+    "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'.": {
         "category": "Error",
         "code": 1085
     },
@@ -855,6 +855,10 @@
         "category": "Error",
         "code": 1318
     },
+    "A default export can only be used in an ECMAScript-style module.": {
+        "category": "Error",
+        "code": 1319
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -1771,6 +1775,14 @@
         "category": "Error",
         "code": 2542
     },
+    "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference.": {
+        "category": "Error",
+        "code": 2543
+    },
+    "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference.": {
+        "category": "Error",
+        "code": 2544
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600
@@ -1807,6 +1819,10 @@
         "category": "Error",
         "code": 2608
     },
+    "JSX spread child must be an array type.": {
+        "category": "Error",
+        "code": 2609
+    },
     "Cannot emit namespaced JSX elements in React": {
         "category": "Error",
         "code": 2650
@@ -2011,6 +2027,14 @@
         "category": "Error",
         "code": 2702
     },
+    "The operand of a delete operator must be a property reference": {
+        "category": "Error",
+        "code": 2703
+    },
+    "The operand of a delete operator cannot be a read-only property": {
+        "category": "Error",
+        "code": 2704
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -2685,6 +2709,10 @@
         "category": "Message",
         "code": 6080
     },
+    "File '{0}' has an unsupported extension, so skipping it.": {
+        "category": "Message",
+        "code": 6081
+    },
     "Only 'amd' and 'system' modules are supported alongside --{0}.": {
         "category": "Error",
         "code": 6082
@@ -2737,7 +2765,7 @@
         "category": "Message",
         "code": 6094
     },
-    "Loading module as file / folder, candidate module location '{0}'.": {
+    "Loading module as file / folder, candidate module location '{0}', target file type '{1}'.": {
         "category": "Message",
         "code": 6095
     },
@@ -2749,7 +2777,7 @@
         "category": "Message",
         "code": 6097
     },
-    "Loading module '{0}' from 'node_modules' folder.": {
+    "Loading module '{0}' from 'node_modules' folder, target file type '{1}'.": {
         "category": "Message",
         "code": 6098
     },
@@ -2945,6 +2973,14 @@
         "category": "Message",
         "code": 6146
     },
+    "Resolution for module '{0}' was found in cache.": {
+        "category": "Message",
+        "code": 6147
+    },
+    "Directory '{0}' does not exist, skipping all lookups in it.": {
+        "category": "Message",
+        "code": 6148
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005
@@ -3169,6 +3205,14 @@
         "category": "Error",
         "code": 17011
     },
+    "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{0}'?": {
+        "category": "Error",
+        "code": 17012
+    },
+    "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor.": {
+        "category": "Error",
+        "code": 17013
+    },
 
     "Circularity detected while resolving configuration: {0}": {
         "category": "Error",
@@ -3195,23 +3239,19 @@
         "category": "Message",
         "code": 90002
     },
-    "Change 'extends' to 'implements'": {
+    "Change 'extends' to 'implements'.": {
         "category": "Message",
         "code": 90003
     },
-    "Remove unused identifiers": {
+    "Remove unused identifiers.": {
         "category": "Message",
         "code": 90004
     },
-    "Implement interface on reference": {
-        "category": "Message",
-        "code": 90005
-    },
-    "Implement interface on class": {
+    "Implement interface '{0}'.": {
         "category": "Message",
         "code": 90006
     },
-    "Implement inherited abstract class": {
+    "Implement inherited abstract class.": {
         "category": "Message",
         "code": 90007
     },
@@ -3234,5 +3274,13 @@
     "Add {0} to existing import declaration from {1}": {
         "category": "Message",
         "code": 90015
+    },
+    "Octal literal types must use ES2015 syntax. Use the syntax '{0}'.": {
+        "category": "Error",
+        "code": 8017
+    },
+    "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'.": {
+        "category": "Error",
+        "code": 8018
     }
 }

src/compiler/emitter.ts

@@ -660,6 +660,8 @@ namespace ts {
                     return emitAsExpression(<AsExpression>node);
                 case SyntaxKind.NonNullExpression:
                     return emitNonNullExpression(<NonNullExpression>node);
+                case SyntaxKind.MetaProperty:
+                    return emitMetaProperty(<MetaProperty>node);
 
                 // JSX
                 case SyntaxKind.JsxElement:
@@ -670,8 +672,6 @@ namespace ts {
                 // Transformation nodes
                 case SyntaxKind.PartiallyEmittedExpression:
                     return emitPartiallyEmittedExpression(<PartiallyEmittedExpression>node);
-                case SyntaxKind.RawExpression:
-                    return writeLines((<RawExpression>node).text);
             }
         }
 
@@ -1249,6 +1249,12 @@ namespace ts {
             write("!");
         }
 
+        function emitMetaProperty(node: MetaProperty) {
+            writeToken(node.keywordToken, node.pos);
+            write(".");
+            emit(node.name);
+        }
+
         //
         // Misc
         //
@@ -1305,28 +1311,28 @@ namespace ts {
             writeToken(SyntaxKind.OpenParenToken, openParenPos, node);
             emitExpression(node.expression);
             writeToken(SyntaxKind.CloseParenToken, node.expression.end, node);
-            emitEmbeddedStatement(node.thenStatement);
+            emitEmbeddedStatement(node, node.thenStatement);
             if (node.elseStatement) {
-                writeLine();
+                writeLineOrSpace(node);
                 writeToken(SyntaxKind.ElseKeyword, node.thenStatement.end, node);
                 if (node.elseStatement.kind === SyntaxKind.IfStatement) {
                     write(" ");
                     emit(node.elseStatement);
                 }
                 else {
-                    emitEmbeddedStatement(node.elseStatement);
+                    emitEmbeddedStatement(node, node.elseStatement);
                 }
             }
         }
 
         function emitDoStatement(node: DoStatement) {
             write("do");
-            emitEmbeddedStatement(node.statement);
+            emitEmbeddedStatement(node, node.statement);
             if (isBlock(node.statement)) {
                 write(" ");
             }
             else {
-                writeLine();
+                writeLineOrSpace(node);
             }
 
             write("while (");
@@ -1338,7 +1344,7 @@ namespace ts {
             write("while (");
             emitExpression(node.expression);
             write(")");
-            emitEmbeddedStatement(node.statement);
+            emitEmbeddedStatement(node, node.statement);
         }
 
         function emitForStatement(node: ForStatement) {
@@ -1351,7 +1357,7 @@ namespace ts {
             write(";");
             emitExpressionWithPrefix(" ", node.incrementor);
             write(")");
-            emitEmbeddedStatement(node.statement);
+            emitEmbeddedStatement(node, node.statement);
         }
 
         function emitForInStatement(node: ForInStatement) {
@@ -1362,7 +1368,7 @@ namespace ts {
             write(" in ");
             emitExpression(node.expression);
             writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            emitEmbeddedStatement(node.statement);
+            emitEmbeddedStatement(node, node.statement);
         }
 
         function emitForOfStatement(node: ForOfStatement) {
@@ -1373,7 +1379,7 @@ namespace ts {
             write(" of ");
             emitExpression(node.expression);
             writeToken(SyntaxKind.CloseParenToken, node.expression.end);
-            emitEmbeddedStatement(node.statement);
+            emitEmbeddedStatement(node, node.statement);
         }
 
         function emitForBinding(node: VariableDeclarationList | Expression) {
@@ -1409,7 +1415,7 @@ namespace ts {
             write("with (");
             emitExpression(node.expression);
             write(")");
-            emitEmbeddedStatement(node.statement);
+            emitEmbeddedStatement(node, node.statement);
         }
 
         function emitSwitchStatement(node: SwitchStatement) {
@@ -1437,9 +1443,12 @@ namespace ts {
         function emitTryStatement(node: TryStatement) {
             write("try ");
             emit(node.tryBlock);
-            emit(node.catchClause);
+            if (node.catchClause) {
+                writeLineOrSpace(node);
+                emit(node.catchClause);
+            }
             if (node.finallyBlock) {
-                writeLine();
+                writeLineOrSpace(node);
                 write("finally ");
                 emit(node.finallyBlock);
             }
@@ -1851,6 +1860,9 @@ namespace ts {
         function emitJsxExpression(node: JsxExpression) {
             if (node.expression) {
                 write("{");
+                if (node.dotDotDotToken) {
+                    write("...");
+                }
                 emitExpression(node.expression);
                 write("}");
             }
@@ -2125,8 +2137,8 @@ namespace ts {
             }
         }
 
-        function emitEmbeddedStatement(node: Statement) {
-            if (isBlock(node)) {
+        function emitEmbeddedStatement(parent: Node, node: Statement) {
+            if (isBlock(node) || getEmitFlags(parent) & EmitFlags.SingleLine) {
                 write(" ");
                 emit(node);
             }
@@ -2291,6 +2303,15 @@ namespace ts {
             }
         }
 
+        function writeLineOrSpace(node: Node) {
+            if (getEmitFlags(node) & EmitFlags.SingleLine) {
+                write(" ");
+            }
+            else {
+                writeLine();
+            }
+        }
+
         function writeIfAny(nodes: NodeArray<Node>, text: string) {
             if (nodes && nodes.length > 0) {
                 write(text);
@@ -2571,6 +2592,13 @@ namespace ts {
             return makeUniqueName("class");
         }
 
+        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration) {
+            if (isIdentifier(node.name)) {
+                return generateNameForNodeCached(node.name);
+            }
+            return makeTempVariableName(TempFlags.Auto);
+        }
+
         /**
          * Generates a unique name from a node.
          *
@@ -2592,6 +2620,10 @@ namespace ts {
                     return generateNameForExportDefault();
                 case SyntaxKind.ClassExpression:
                     return generateNameForClassExpression();
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node);
                 default:
                     return makeTempVariableName(TempFlags.Auto);
             }
@@ -2642,6 +2674,11 @@ namespace ts {
             return node;
         }
 
+        function generateNameForNodeCached(node: Node) {
+            const nodeId = getNodeId(node);
+            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node)));
+        }
+
         /**
          * Gets the generated identifier text from a generated identifier.
          *
@@ -2652,8 +2689,7 @@ namespace ts {
                 // Generated names generate unique names based on their original node
                 // and are cached based on that node's id
                 const node = getNodeForGeneratedName(name);
-                const nodeId = getNodeId(node);
-                return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node)));
+                return generateNameForNodeCached(node);
             }
             else {
                 // Auto, Loop, and Unique names are cached based on their unique

src/compiler/factory.ts

@@ -1317,15 +1317,16 @@ namespace ts {
         return node;
     }
 
-    export function createJsxExpression(expression: Expression, location?: TextRange) {
+    export function createJsxExpression(expression: Expression, dotDotDotToken: Token<SyntaxKind.DotDotDotToken>, location?: TextRange) {
         const node = <JsxExpression>createNode(SyntaxKind.JsxExpression, location);
+        node.dotDotDotToken = dotDotDotToken;
         node.expression = expression;
         return node;
     }
 
     export function updateJsxExpression(node: JsxExpression, expression: Expression) {
         if (node.expression !== expression) {
-            return updateNode(createJsxExpression(expression, node), node);
+            return updateNode(createJsxExpression(expression, node.dotDotDotToken, node), node);
         }
         return node;
     }
@@ -1529,19 +1530,6 @@ namespace ts {
         return node;
     }
 
-    /**
-     * Creates a node that emits a string of raw text in an expression position. Raw text is never
-     * transformed, should be ES3 compliant, and should have the same precedence as
-     * PrimaryExpression.
-     *
-     * @param text The raw text of the node.
-     */
-    export function createRawExpression(text: string) {
-        const node = <RawExpression>createNode(SyntaxKind.RawExpression);
-        node.text = text;
-        return node;
-    }
-
     // Compound nodes
 
     export function createComma(left: Expression, right: Expression) {
@@ -1754,6 +1742,23 @@ namespace ts {
 
     // Utilities
 
+    export function restoreEnclosingLabel(node: Statement, outermostLabeledStatement: LabeledStatement, afterRestoreLabelCallback?: (node: LabeledStatement) => void): Statement {
+        if (!outermostLabeledStatement) {
+            return node;
+        }
+        const updated = updateLabel(
+            outermostLabeledStatement,
+            outermostLabeledStatement.label,
+            outermostLabeledStatement.statement.kind === SyntaxKind.LabeledStatement
+                ? restoreEnclosingLabel(node, <LabeledStatement>outermostLabeledStatement.statement)
+                : node
+        );
+        if (afterRestoreLabelCallback) {
+            afterRestoreLabelCallback(outermostLabeledStatement);
+        }
+        return updated;
+    }
+
     export interface CallBinding {
         target: LeftHandSideExpression;
         thisArg: Expression;

src/compiler/moduleNameResolver.ts

@@ -1,4 +1,4 @@
-/// <reference path="core.ts" />
+/// <reference path="core.ts" />
 /// <reference path="diagnosticInformationMap.generated.ts" />
 
 namespace ts {
@@ -32,7 +32,7 @@ namespace ts {
      * Kinds of file that we are currently looking for.
      * Typically there is one pass with Extensions.TypeScript, then a second pass with Extensions.JavaScript.
      */
-    const enum Extensions {
+    enum Extensions {
         TypeScript, /** '.ts', '.tsx', or '.d.ts' */
         JavaScript, /** '.js' or '.jsx' */
         DtsOnly /** Only '.d.ts' */
@@ -47,11 +47,6 @@ namespace ts {
         return resolved.path;
     }
 
-    /** Create Resolved from a file with unknown extension. */
-    function resolvedFromAnyFile(path: string): Resolved | undefined {
-        return { path, extension: extensionFromPath(path) };
-    }
-
     /** Adds `isExernalLibraryImport` to a Resolved to get a ResolvedModule. */
     function resolvedModuleFromResolved({ path, extension }: Resolved, isExternalLibraryImport: boolean): ResolvedModuleFull {
         return { resolvedFileName: path, extension, isExternalLibraryImport };
@@ -71,7 +66,8 @@ namespace ts {
         traceEnabled: boolean;
     }
 
-    function tryReadTypesSection(extensions: Extensions, packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
+    /** Reads from "main" or "types"/"typings" depending on `extensions`. */
+    function tryReadPackageJsonMainOrTypes(extensions: Extensions, packageJsonPath: string, baseDirectory: string, state: ModuleResolutionState): string {
         const jsonContent = readJson(packageJsonPath, state.host);
 
         switch (extensions) {
@@ -153,6 +149,7 @@ namespace ts {
             if (host.directoryExists(atTypes)) {
                 (typeRoots || (typeRoots = [])).push(atTypes);
             }
+            return undefined;
         });
         return typeRoots;
     }
@@ -220,9 +217,13 @@ namespace ts {
                 return forEach(typeRoots, typeRoot => {
                     const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
                     const candidateDirectory = getDirectoryPath(candidate);
+                    const directoryExists = directoryProbablyExists(candidateDirectory, host);
+                    if (!directoryExists && traceEnabled) {
+                        trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
+                    }
                     return resolvedTypeScriptOnly(
                         loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate, failedLookupLocations,
-                            !directoryProbablyExists(candidateDirectory, host), moduleResolutionState));
+                            !directoryExists, moduleResolutionState));
                 });
             }
             else {
@@ -241,7 +242,8 @@ namespace ts {
                 if (traceEnabled) {
                     trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
                 }
-                resolvedFile = resolvedTypeScriptOnly(loadModuleFromNodeModules(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState));
+                const result = loadModuleFromNodeModules(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState, /*cache*/ undefined);
+                resolvedFile = resolvedTypeScriptOnly(result && result.value);
                 if (!resolvedFile && traceEnabled) {
                     trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
                 }
@@ -293,33 +295,171 @@ namespace ts {
         return result;
     }
 
-    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+    /**
+     * Cached module resolutions per containing directory.
+     * This assumes that any module id will have the same resolution for sibling files located in the same folder.
+     */
+    export interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
+        getOrCreateCacheForDirectory(directoryName: string): Map<ResolvedModuleWithFailedLookupLocations>;
+    }
+
+    /**
+     * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory
+     * We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive.
+     */
+    export interface NonRelativeModuleNameResolutionCache {
+        getOrCreateCacheForModuleName(nonRelativeModuleName: string): PerModuleNameCache;
+    }
+
+    export interface PerModuleNameCache {
+        get(directory: string): ResolvedModuleWithFailedLookupLocations;
+        set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void;
+    }
+
+    export function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string): ModuleResolutionCache {
+        const directoryToModuleNameMap = createFileMap<Map<ResolvedModuleWithFailedLookupLocations>>();
+        const moduleNameToDirectoryMap = createMap<PerModuleNameCache>();
+
+        return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName };
+
+        function getOrCreateCacheForDirectory(directoryName: string) {
+            const path = toPath(directoryName, currentDirectory, getCanonicalFileName);
+            let perFolderCache = directoryToModuleNameMap.get(path);
+            if (!perFolderCache) {
+                perFolderCache = createMap<ResolvedModuleWithFailedLookupLocations>();
+                directoryToModuleNameMap.set(path, perFolderCache);
+            }
+            return perFolderCache;
+        }
+
+        function getOrCreateCacheForModuleName(nonRelativeModuleName: string) {
+            if (!moduleHasNonRelativeName(nonRelativeModuleName)) {
+                return undefined;
+            }
+            let perModuleNameCache = moduleNameToDirectoryMap[nonRelativeModuleName];
+            if (!perModuleNameCache) {
+                moduleNameToDirectoryMap[nonRelativeModuleName] = perModuleNameCache = createPerModuleNameCache();
+            }
+            return perModuleNameCache;
+        }
+
+        function createPerModuleNameCache(): PerModuleNameCache {
+            const directoryPathMap = createFileMap<ResolvedModuleWithFailedLookupLocations>();
+
+            return { get, set };
+
+            function get(directory: string): ResolvedModuleWithFailedLookupLocations {
+                return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
+            }
+
+            /**
+             * At first this function add entry directory -> module resolution result to the table.
+             * Then it computes the set of parent folders for 'directory' that should have the same module resolution result
+             * and for every parent folder in set it adds entry: parent -> module resolution. .
+             * Lets say we first directory name: /a/b/c/d/e and resolution result is: /a/b/bar.ts.
+             * Set of parent folders that should have the same result will be: 
+             * [
+             *     /a/b/c/d, /a/b/c, /a/b
+             * ]
+             * this means that request for module resolution from file in any of these folder will be immediately found in cache.
+             */
+            function set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void {
+                const path = toPath(directory, currentDirectory, getCanonicalFileName);
+                // if entry is already in cache do nothing
+                if (directoryPathMap.contains(path)) {
+                    return;
+                }
+                directoryPathMap.set(path, result);
+
+                const resolvedFileName = result.resolvedModule && result.resolvedModule.resolvedFileName;
+                // find common prefix between directory and resolved file name
+                // this common prefix should be the shorted path that has the same resolution
+                // directory: /a/b/c/d/e
+                // resolvedFileName: /a/b/foo.d.ts
+                const commonPrefix = getCommonPrefix(path, resolvedFileName);
+                let current = path;
+                while (true) {
+                    const parent = getDirectoryPath(current);
+                    if (parent === current || directoryPathMap.contains(parent)) {
+                        break;
+                    }
+                    directoryPathMap.set(parent, result);
+                    current = parent;
+
+                    if (current == commonPrefix) {
+                        break;
+                    }
+                }
+            }
+            
+            function getCommonPrefix(directory: Path, resolution: string) {
+                if (resolution === undefined) {
+                    return undefined;
+                }
+                const resolutionDirectory = toPath(getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);
+
+                // find first position where directory and resolution differs
+                let i = 0;
+                while (i < Math.min(directory.length, resolutionDirectory.length) && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {
+                    i++;
+                }
+
+                // find last directory separator before position i
+                const sep = directory.lastIndexOf(directorySeparator, i);
+                if (sep < 0) {
+                    return undefined;
+                }
+
+                return directory.substr(0, sep);
+            }
+        }
+    }
+
+    export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations {
         const traceEnabled = isTraceEnabled(compilerOptions, host);
         if (traceEnabled) {
             trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
         }
+        const containingDirectory = getDirectoryPath(containingFile);
+        let perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
+        let result = perFolderCache && perFolderCache[moduleName];
 
-        let moduleResolution = compilerOptions.moduleResolution;
-        if (moduleResolution === undefined) {
-            moduleResolution = getEmitModuleKind(compilerOptions) === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic;
+        if (result) {
             if (traceEnabled) {
-                trace(host, Diagnostics.Module_resolution_kind_is_not_specified_using_0, ModuleResolutionKind[moduleResolution]);
+                trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache, moduleName);
             }
         }
         else {
-            if (traceEnabled) {
-                trace(host, Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ModuleResolutionKind[moduleResolution]);
+            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;
+            switch (moduleResolution) {
+                case ModuleResolutionKind.NodeJs:
+                    result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache);
+                    break;
+                case ModuleResolutionKind.Classic:
+                    result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache);
+                    break;
+            }
+
+            if (perFolderCache) {
+                perFolderCache[moduleName] = result;
+                // put result in per-module name cache
+                const perModuleNameCache = cache.getOrCreateCacheForModuleName(moduleName);
+                if (perModuleNameCache) {
+                    perModuleNameCache.set(containingDirectory, result);
+                }
+            }
         }
 
         if (traceEnabled) {
@@ -542,7 +682,7 @@ namespace ts {
         }
     }
 
-    export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+    export function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations {
         const containingDirectory = getDirectoryPath(containingFile);
         const traceEnabled = isTraceEnabled(compilerOptions, host);
 
@@ -550,30 +690,30 @@ namespace ts {
         const state: ModuleResolutionState = { compilerOptions, host, traceEnabled };
 
         const result = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
-        if (result) {
-            const { resolved, isExternalLibraryImport } = result;
+        if (result && result.value) {
+            const { resolved, isExternalLibraryImport } = result.value;
             return createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations);
         }
         return { resolvedModule: undefined, failedLookupLocations };
 
-        function tryResolve(extensions: Extensions): { resolved: Resolved, isExternalLibraryImport: boolean } | undefined {
+        function tryResolve(extensions: Extensions): SearchResult<{ resolved: Resolved, isExternalLibraryImport: boolean }> {
             const resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, nodeLoadModuleByRelativeName, failedLookupLocations, state);
             if (resolved) {
-                return { resolved, isExternalLibraryImport: false };
+                return toSearchResult({ resolved, isExternalLibraryImport: false });
             }
 
             if (moduleHasNonRelativeName(moduleName)) {
                 if (traceEnabled) {
-                    trace(host, Diagnostics.Loading_module_0_from_node_modules_folder, moduleName);
+                    trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);
                 }
-                const resolved = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state);
+                const resolved = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state, cache);
                 // For node_modules lookups, get the real path so that multiple accesses to an `npm link`-ed module do not create duplicate files.
-                return resolved && { resolved: { path: realpath(resolved.path, host, traceEnabled), extension: resolved.extension }, isExternalLibraryImport: true };
+                return resolved && { value: resolved.value && { resolved: { path: realpath(resolved.value.path, host, traceEnabled), extension: resolved.value.extension }, isExternalLibraryImport: true } };
             }
             else {
                 const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
                 const resolved = nodeLoadModuleByRelativeName(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state);
-                return resolved && { resolved, isExternalLibraryImport: false };
+                return resolved && toSearchResult({ resolved, isExternalLibraryImport: false });
             }
         }
     }
@@ -592,11 +732,33 @@ namespace ts {
 
     function nodeLoadModuleByRelativeName(extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState): Resolved | undefined {
         if (state.traceEnabled) {
-            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0, candidate);
+            trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]);
         }
-
-        const resolvedFromFile = !pathEndsWithDirectorySeparator(candidate) && loadModuleFromFile(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
-        return resolvedFromFile || loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
+        if (!pathEndsWithDirectorySeparator(candidate)) {
+            if (!onlyRecordFailures) {
+                const parentOfCandidate = getDirectoryPath(candidate);
+                if (!directoryProbablyExists(parentOfCandidate, state.host)) {
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);
+                    }
+                    onlyRecordFailures = true;
+                }
+            }
+            const resolvedFromFile = loadModuleFromFile(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
+            if (resolvedFromFile) {
+                return resolvedFromFile;
+            }
+        }
+        if (!onlyRecordFailures) {
+            const candidateExists = directoryProbablyExists(candidate, state.host);
+            if (!candidateExists) {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate);
+                }
+                onlyRecordFailures = true;
+            }
+        }
+        return loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);
     }
 
     /* @internal */
@@ -655,19 +817,21 @@ namespace ts {
 
     /** Return the file if it exists. */
     function tryFile(fileName: string, failedLookupLocations: Push<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);
+        if (!onlyRecordFailures) {
+            if (state.host.fileExists(fileName)) {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
+                }
+                return fileName;
             }
-            return fileName;
-        }
-        else {
-            if (state.traceEnabled) {
-                trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
+            else {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
+                }
             }
-            failedLookupLocations.push(fileName);
-            return undefined;
         }
+        failedLookupLocations.push(fileName);
+        return undefined;
     }
 
     function loadNodeModuleFromDirectory(extensions: Extensions, candidate: string, failedLookupLocations: Push<string>, onlyRecordFailures: boolean, state: ModuleResolutionState): Resolved | undefined {
@@ -678,18 +842,23 @@ namespace ts {
             if (state.traceEnabled) {
                 trace(state.host, Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
-            const typesFile = tryReadTypesSection(extensions, packageJsonPath, candidate, state);
-            if (typesFile) {
-                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
+            const mainOrTypesFile = tryReadPackageJsonMainOrTypes(extensions, packageJsonPath, candidate, state);
+            if (mainOrTypesFile) {
+                const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(mainOrTypesFile), state.host);
                 // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
-                const fromFile = tryFile(typesFile, failedLookupLocations, onlyRecordFailures, state);
-                if (fromFile) {
-                    // Note: this would allow a package.json to specify a ".js" file as typings. Maybe that should be forbidden.
-                    return resolvedFromAnyFile(fromFile);
+                const fromExactFile = tryFile(mainOrTypesFile, failedLookupLocations, onlyRecordFailures, state);
+                if (fromExactFile) {
+                    const resolved = fromExactFile && resolvedIfExtensionMatches(extensions, fromExactFile);
+                    if (resolved) {
+                        return resolved;
+                    }
+                    if (state.traceEnabled) {
+                        trace(state.host, Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromExactFile);
+                    }
                 }
-                const x = tryAddingExtensions(typesFile, Extensions.TypeScript, failedLookupLocations, onlyRecordFailures, state);
-                if (x) {
-                    return x;
+                const resolved = tryAddingExtensions(mainOrTypesFile, Extensions.TypeScript, failedLookupLocations, onlyRecordFailures, state);
+                if (resolved) {
+                    return resolved;
                 }
             }
             else {
@@ -699,7 +868,7 @@ namespace ts {
             }
         }
         else {
-            if (state.traceEnabled) {
+            if (directoryExists && 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
@@ -709,66 +878,116 @@ namespace ts {
         return loadModuleFromFile(extensions, combinePaths(candidate, "index"), failedLookupLocations, !directoryExists, state);
     }
 
+    /** Resolve from an arbitrarily specified file. Return `undefined` if it has an unsupported extension. */
+    function resolvedIfExtensionMatches(extensions: Extensions, path: string): Resolved | undefined {
+        const extension = tryGetExtensionFromPath(path);
+        return extension !== undefined && extensionIsOk(extensions, extension) ? { path, extension } : undefined;
+    }
+
+    /** True if `extension` is one of the supported `extensions`. */
+    function extensionIsOk(extensions: Extensions, extension: Extension): boolean {
+        switch (extensions) {
+            case Extensions.JavaScript:
+                return extension === Extension.Js || extension === Extension.Jsx;
+            case Extensions.TypeScript:
+                return extension === Extension.Ts || extension === Extension.Tsx || extension === Extension.Dts;
+            case Extensions.DtsOnly:
+                return extension === Extension.Dts;
+        }
+    }
+
     function pathToPackageJson(directory: string): string {
         return combinePaths(directory, "package.json");
     }
 
-    function loadModuleFromNodeModulesFolder(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
-        const nodeModulesFolder = combinePaths(directory, "node_modules");
-        const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
+    function loadModuleFromNodeModulesFolder(extensions: Extensions, moduleName: string, nodeModulesFolder: string, nodeModulesFolderExists: boolean, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
         const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
 
         return loadModuleFromFile(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state) ||
             loadNodeModuleFromDirectory(extensions, candidate, failedLookupLocations, !nodeModulesFolderExists, state);
     }
 
-    function loadModuleFromNodeModules(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
-        return loadModuleFromNodeModulesWorker(extensions, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ false);
+    function loadModuleFromNodeModules(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState, cache: NonRelativeModuleNameResolutionCache): SearchResult<Resolved> {
+        return loadModuleFromNodeModulesWorker(extensions, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ false, cache);
     }
-    function loadModuleFromNodeModulesAtTypes(moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {
+    function loadModuleFromNodeModulesAtTypes(moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState): SearchResult<Resolved> {
         // Extensions parameter here doesn't actually matter, because typesOnly ensures we're just doing @types lookup, which is always DtsOnly.
-        return loadModuleFromNodeModulesWorker(Extensions.DtsOnly, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ true);
+        return loadModuleFromNodeModulesWorker(Extensions.DtsOnly, moduleName, directory, failedLookupLocations, state, /*typesOnly*/ true, /*cache*/ undefined);
     }
 
-    function loadModuleFromNodeModulesWorker(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState, typesOnly: boolean): Resolved | undefined {
+    function loadModuleFromNodeModulesWorker(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState, typesOnly: boolean, cache: NonRelativeModuleNameResolutionCache): SearchResult<Resolved> {
+        const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName);
         return forEachAncestorDirectory(normalizeSlashes(directory), ancestorDirectory => {
             if (getBaseFileName(ancestorDirectory) !== "node_modules") {
-                return loadModuleFromNodeModulesOneLevel(extensions, moduleName, ancestorDirectory, failedLookupLocations, state, typesOnly);
+                const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state.traceEnabled, state.host);
+                if (resolutionFromCache) {
+                    return resolutionFromCache;
+                }
+                return toSearchResult(loadModuleFromNodeModulesOneLevel(extensions, moduleName, ancestorDirectory, failedLookupLocations, state, typesOnly));
             }
         });
     }
 
     /** Load a module from a single node_modules directory, but not from any ancestors' node_modules directories. */
     function loadModuleFromNodeModulesOneLevel(extensions: Extensions, moduleName: string, directory: string, failedLookupLocations: Push<string>, state: ModuleResolutionState, typesOnly = false): Resolved | undefined {
-        const packageResult = typesOnly ? undefined : loadModuleFromNodeModulesFolder(extensions, moduleName, directory, failedLookupLocations, state);
+        const nodeModulesFolder = combinePaths(directory, "node_modules");
+        const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
+        if (!nodeModulesFolderExists && state.traceEnabled) {
+            trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
+        }
+
+        const packageResult = typesOnly ? undefined : loadModuleFromNodeModulesFolder(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, failedLookupLocations, state);
         if (packageResult) {
             return packageResult;
         }
         if (extensions !== Extensions.JavaScript) {
-            return loadModuleFromNodeModulesFolder(Extensions.DtsOnly, combinePaths("@types", moduleName), directory, failedLookupLocations, state);
+            const nodeModulesAtTypes = combinePaths(nodeModulesFolder, "@types");
+            let nodeModulesAtTypesExists = nodeModulesFolderExists;
+            if (nodeModulesFolderExists && !directoryProbablyExists(nodeModulesAtTypes, state.host)) {
+                if (state.traceEnabled) {
+                    trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes);
+                }
+                nodeModulesAtTypesExists = false;
+            }
+            return loadModuleFromNodeModulesFolder(Extensions.DtsOnly, moduleName, nodeModulesAtTypes, nodeModulesAtTypesExists, failedLookupLocations, state);
         }
     }
 
-    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {
+    function tryFindNonRelativeModuleNameInCache(cache: PerModuleNameCache | undefined, moduleName: string, containingDirectory: string, traceEnabled: boolean, host: ModuleResolutionHost): SearchResult<Resolved> {
+        const result = cache && cache.get(containingDirectory);
+        if (result) {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache, moduleName)
+            }
+            return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension } };
+        }
+    }
+
+    export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache): ResolvedModuleWithFailedLookupLocations {
         const traceEnabled = isTraceEnabled(compilerOptions, host);
         const state: ModuleResolutionState = { compilerOptions, host, traceEnabled };
         const failedLookupLocations: string[] = [];
         const containingDirectory = getDirectoryPath(containingFile);
 
         const resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
-        return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ false, failedLookupLocations);
+        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, /*isExternalLibraryImport*/ false, failedLookupLocations);
 
-        function tryResolve(extensions: Extensions): Resolved | undefined {
+        function tryResolve(extensions: Extensions): SearchResult<Resolved> {
             const resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFile, failedLookupLocations, state);
             if (resolvedUsingSettings) {
-                return resolvedUsingSettings;
+                return { value: resolvedUsingSettings };
             }
+            const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName);
 
             if (moduleHasNonRelativeName(moduleName)) {
                 // Climb up parent directories looking for a module.
                 const resolved = forEachAncestorDirectory(containingDirectory, directory => {
+                    const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, directory, traceEnabled, host);
+                    if (resolutionFromCache) {
+                        return resolutionFromCache;
+                    }
                     const searchName = normalizePath(combinePaths(directory, moduleName));
-                    return loadModuleFromFile(extensions, searchName, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+                    return toSearchResult(loadModuleFromFile(extensions, searchName, failedLookupLocations, /*onlyRecordFailures*/ false, state));
                 });
                 if (resolved) {
                     return resolved;
@@ -780,7 +999,7 @@ namespace ts {
             }
             else {
                 const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-                return loadModuleFromFile(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state);
+                return toSearchResult(loadModuleFromFile(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state));
             }
         }
     }
@@ -801,8 +1020,28 @@ namespace ts {
         return createResolvedModuleWithFailedLookupLocations(resolved, /*isExternalLibraryImport*/ true, failedLookupLocations);
     }
 
+    /**
+     * Represents result of search. Normally when searching among several alternatives we treat value `undefined` as indicator
+     * that search fails and we should try another option. 
+     * However this does not allow us to represent final result that should be used instead of further searching (i.e. a final result that was found in cache).
+     * SearchResult is used to deal with this issue, its values represents following outcomes:
+     * - undefined - not found, continue searching
+     * - { value: undefined } - not found - stop searching
+     * - { value: <some-value> } - found - stop searching
+     */
+    type SearchResult<T> = { value: T | undefined } | undefined;
+    
+    /**
+     * Wraps value to SearchResult.
+     * @returns undefined if value is undefined or { value } otherwise
+     */
+    function toSearchResult<T>(value: T | undefined): SearchResult<T> {
+        return value !== undefined ? { value } : undefined;
+    }
+
+
     /** Calls `callback` on `directory` and every ancestor directory it has, returning the first defined result. */
-    function forEachAncestorDirectory<T>(directory: string, callback: (directory: string) => T | undefined): T | undefined {
+    function forEachAncestorDirectory<T>(directory: string, callback: (directory: string) => SearchResult<T>): SearchResult<T> {
         while (true) {
             const result = callback(directory);
             if (result !== undefined) {

src/compiler/parser.ts

@@ -198,6 +198,8 @@ namespace ts {
                     visitNode(cbNode, (<AsExpression>node).type);
             case SyntaxKind.NonNullExpression:
                 return visitNode(cbNode, (<NonNullExpression>node).expression);
+            case SyntaxKind.MetaProperty:
+                return visitNode(cbNode, (<MetaProperty>node).name);
             case SyntaxKind.ConditionalExpression:
                 return visitNode(cbNode, (<ConditionalExpression>node).condition) ||
                     visitNode(cbNode, (<ConditionalExpression>node).questionToken) ||
@@ -373,7 +375,8 @@ namespace ts {
             case SyntaxKind.JsxSpreadAttribute:
                 return visitNode(cbNode, (<JsxSpreadAttribute>node).expression);
             case SyntaxKind.JsxExpression:
-                return visitNode(cbNode, (<JsxExpression>node).expression);
+                return visitNode(cbNode, (node as JsxExpression).dotDotDotToken) ||
+                    visitNode(cbNode, (node as JsxExpression).expression);
             case SyntaxKind.JsxClosingElement:
                 return visitNode(cbNode, (<JsxClosingElement>node).tagName);
 
@@ -1678,8 +1681,8 @@ namespace ts {
                         // Method declarations are not necessarily reusable.  An object-literal
                         // may have a method calls "constructor(...)" and we must reparse that
                         // into an actual .ConstructorDeclaration.
-                        let methodDeclaration = <MethodDeclaration>node;
-                        let nameIsConstructor = methodDeclaration.name.kind === SyntaxKind.Identifier &&
+                        const methodDeclaration = <MethodDeclaration>node;
+                        const nameIsConstructor = methodDeclaration.name.kind === SyntaxKind.Identifier &&
                             (<Identifier>methodDeclaration.name).originalKeywordKind === SyntaxKind.ConstructorKeyword;
 
                         return !nameIsConstructor;
@@ -3914,6 +3917,7 @@ namespace ts {
 
             parseExpected(SyntaxKind.OpenBraceToken);
             if (token() !== SyntaxKind.CloseBraceToken) {
+                node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
                 node.expression = parseAssignmentExpressionOrHigher();
             }
             if (inExpressionContext) {
@@ -4329,15 +4333,22 @@ namespace ts {
             return isIdentifier() ? parseIdentifier() : undefined;
         }
 
-        function parseNewExpression(): NewExpression {
-            const node = <NewExpression>createNode(SyntaxKind.NewExpression);
+        function parseNewExpression(): NewExpression | MetaProperty {
+            const fullStart = scanner.getStartPos();
             parseExpected(SyntaxKind.NewKeyword);
+            if (parseOptional(SyntaxKind.DotToken)) {
+                const node = <MetaProperty>createNode(SyntaxKind.MetaProperty, fullStart);
+                node.keywordToken = SyntaxKind.NewKeyword;
+                node.name = parseIdentifierName();
+                return finishNode(node);
+            }
+
+            const node = <NewExpression>createNode(SyntaxKind.NewExpression, fullStart);
             node.expression = parseMemberExpressionOrHigher();
             node.typeArguments = tryParse(parseTypeArgumentsInExpression);
             if (node.typeArguments || token() === SyntaxKind.OpenParenToken) {
                 node.arguments = parseArgumentList();
             }
-
             return finishNode(node);
         }
 
@@ -6337,7 +6348,7 @@ namespace ts {
                                 break;
                             case SyntaxKind.AsteriskToken:
                                 const asterisk = scanner.getTokenText();
-                                if (state === JSDocState.SawAsterisk) {
+                                if (state === JSDocState.SawAsterisk || state === JSDocState.SavingComments) {
                                     // If we've already seen an asterisk, then we can no longer parse a tag on this line
                                     state = JSDocState.SavingComments;
                                     pushComment(asterisk);
@@ -6358,7 +6369,10 @@ namespace ts {
                             case SyntaxKind.WhitespaceTrivia:
                                 // only collect whitespace if we're already saving comments or have just crossed the comment indent margin
                                 const whitespace = scanner.getTokenText();
-                                if (state === JSDocState.SavingComments || margin !== undefined && indent + whitespace.length > margin) {
+                                if (state === JSDocState.SavingComments) {
+                                    comments.push(whitespace);
+                                }
+                                else if (margin !== undefined && indent + whitespace.length > margin) {
                                     comments.push(whitespace.slice(margin - indent - 1));
                                 }
                                 indent += whitespace.length;
@@ -6366,6 +6380,8 @@ namespace ts {
                             case SyntaxKind.EndOfFileToken:
                                 break;
                             default:
+                                // anything other than whitespace or asterisk at the beginning of the line starts the comment text
+                                state = JSDocState.SavingComments;
                                 pushComment(scanner.getTokenText());
                                 break;
                         }
@@ -7399,7 +7415,7 @@ namespace ts {
                     if (position >= array.pos && position < array.end) {
                         // position was in this array.  Search through this array to see if we find a
                         // viable element.
-                        for (let i = 0, n = array.length; i < n; i++) {
+                        for (let i = 0; i < array.length; i++) {
                             const child = array[i];
                             if (child) {
                                 if (child.pos === position) {

src/compiler/program.ts

@@ -40,7 +40,8 @@ namespace ts {
                 return;
             }
 
-            for (let i = 0, n = Math.min(commonPathComponents.length, sourcePathComponents.length); i < n; i++) {
+            const n = Math.min(commonPathComponents.length, sourcePathComponents.length);
+            for (let i = 0; i < n; i++) {
                 if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) {
                     if (i === 0) {
                         // Failed to find any common path component
@@ -325,6 +326,7 @@ namespace ts {
         // Map storing if there is emit blocking diagnostics for given input
         const hasEmitBlockingDiagnostics = createFileMap<boolean>(getCanonicalFileName);
 
+        let moduleResolutionCache: ModuleResolutionCache;
         let resolveModuleNamesWorker: (moduleNames: string[], containingFile: string) => ResolvedModuleFull[];
         if (host.resolveModuleNames) {
             resolveModuleNamesWorker = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile).map(resolved => {
@@ -338,7 +340,8 @@ namespace ts {
             });
         }
         else {
-            const loader = (moduleName: string, containingFile: string) => resolveModuleName(moduleName, containingFile, options, host).resolvedModule;
+            moduleResolutionCache = createModuleResolutionCache(currentDirectory, x => host.getCanonicalFileName(x));
+            const loader = (moduleName: string, containingFile: string) => resolveModuleName(moduleName, containingFile, options, host, moduleResolutionCache).resolvedModule;
             resolveModuleNamesWorker = (moduleNames, containingFile) => loadWithLocalCache(moduleNames, containingFile, loader);
         }
 
@@ -391,6 +394,9 @@ namespace ts {
             }
         }
 
+        // unconditionally set moduleResolutionCache to undefined to avoid unnecessary leaks
+        moduleResolutionCache = undefined;
+
         // unconditionally set oldProgram to undefined to prevent it from being captured in closure
         oldProgram = undefined;
 
@@ -695,7 +701,7 @@ namespace ts {
             }
 
             // update fileName -> file mapping
-            for (let i = 0, len = newSourceFiles.length; i < len; i++) {
+            for (let i = 0; i < newSourceFiles.length; i++) {
                 filesByName.set(filePaths[i], newSourceFiles[i]);
             }
 
@@ -952,7 +958,7 @@ namespace ts {
                             }
                             break;
                         case SyntaxKind.HeritageClause:
-                            let heritageClause = <HeritageClause>node;
+                            const heritageClause = <HeritageClause>node;
                             if (heritageClause.token === SyntaxKind.ImplementsKeyword) {
                                 diagnostics.push(createDiagnosticForNode(node, Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file));
                                 return;
@@ -971,7 +977,7 @@ namespace ts {
                             diagnostics.push(createDiagnosticForNode(node, Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file));
                             return;
                         case SyntaxKind.TypeAssertionExpression:
-                            let typeAssertionExpression = <TypeAssertion>node;
+                            const typeAssertionExpression = <TypeAssertion>node;
                             diagnostics.push(createDiagnosticForNode(typeAssertionExpression.type, Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file));
                             return;
                     }
@@ -1170,7 +1176,7 @@ namespace ts {
                     case SyntaxKind.ImportDeclaration:
                     case SyntaxKind.ImportEqualsDeclaration:
                     case SyntaxKind.ExportDeclaration:
-                        let moduleNameExpr = getExternalModuleName(node);
+                        const moduleNameExpr = getExternalModuleName(node);
                         if (!moduleNameExpr || moduleNameExpr.kind !== SyntaxKind.StringLiteral) {
                             break;
                         }

src/compiler/scanner.ts

@@ -531,7 +531,7 @@ namespace ts {
             const ch = text.charCodeAt(pos);
 
             if ((pos + mergeConflictMarkerLength) < text.length) {
-                for (let i = 0, n = mergeConflictMarkerLength; i < n; i++) {
+                for (let i = 0; i < mergeConflictMarkerLength; i++) {
                     if (text.charCodeAt(pos + i) !== ch) {
                         return false;
                     }
@@ -643,7 +643,7 @@ namespace ts {
                     pos++;
                     continue;
                 case CharacterCodes.slash:
-                    let nextChar = text.charCodeAt(pos + 1);
+                    const nextChar = text.charCodeAt(pos + 1);
                     let hasTrailingNewLine = false;
                     if (nextChar === CharacterCodes.slash || nextChar === CharacterCodes.asterisk) {
                         const kind = nextChar === CharacterCodes.slash ? SyntaxKind.SingleLineCommentTrivia : SyntaxKind.MultiLineCommentTrivia;
@@ -766,7 +766,7 @@ namespace ts {
             return false;
         }
 
-        for (let i = 1, n = name.length; i < n; i++) {
+        for (let i = 1; i < name.length; i++) {
             if (!isIdentifierPart(name.charCodeAt(i), languageVersion)) {
                 return false;
             }
@@ -1563,7 +1563,7 @@ namespace ts {
                         pos++;
                         return token = SyntaxKind.AtToken;
                     case CharacterCodes.backslash:
-                        let cookedChar = peekUnicodeEscape();
+                        const cookedChar = peekUnicodeEscape();
                         if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) {
                             pos += 6;
                             tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts();

src/compiler/sourcemap.ts

@@ -427,7 +427,7 @@ namespace ts {
 
             encodeLastRecordedSourceMapSpan();
 
-            return stringify({
+            return JSON.stringify({
                 version: 3,
                 file: sourceMapData.sourceMapFile,
                 sourceRoot: sourceMapData.sourceMapSourceRoot,

src/compiler/sys.ts

@@ -160,7 +160,7 @@ namespace ts {
 
             function getNames(collection: any): string[] {
                 const result: string[] = [];
-                for (let e = new Enumerator(collection); !e.atEnd(); e.moveNext()) {
+                for (const e = new Enumerator(collection); !e.atEnd(); e.moveNext()) {
                     result.push(e.item().Name);
                 }
                 return result.sort();

src/compiler/transformers/es2017.ts

@@ -494,7 +494,7 @@ namespace ts {
                     function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
                     function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
                     function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-                    step((generator = generator.apply(thisArg, _arguments)).next());
+                    step((generator = generator.apply(thisArg, _arguments || [])).next());
                 });
             };`
     };

src/compiler/transformers/es5.ts

@@ -9,6 +9,20 @@ namespace ts {
      * @param context Context and state information for the transformation.
      */
     export function transformES5(context: TransformationContext) {
+        const compilerOptions = context.getCompilerOptions();
+
+        // enable emit notification only if using --jsx preserve
+        let previousOnEmitNode: (emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) => void;
+        let noSubstitution: boolean[];
+        if (compilerOptions.jsx === JsxEmit.Preserve) {
+            previousOnEmitNode = context.onEmitNode;
+            context.onEmitNode = onEmitNode;
+            context.enableEmitNotification(SyntaxKind.JsxOpeningElement);
+            context.enableEmitNotification(SyntaxKind.JsxClosingElement);
+            context.enableEmitNotification(SyntaxKind.JsxSelfClosingElement);
+            noSubstitution = [];
+        }
+
         const previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
         context.enableSubstitution(SyntaxKind.PropertyAccessExpression);
@@ -24,6 +38,24 @@ namespace ts {
             return node;
         }
 
+        /**
+         * Called by the printer just before a node is printed.
+         *
+         * @param node The node to be printed.
+         */
+        function onEmitNode(emitContext: EmitContext, node: Node, emitCallback: (emitContext: EmitContext, node: Node) => void) {
+            switch (node.kind) {
+                case SyntaxKind.JsxOpeningElement:
+                case SyntaxKind.JsxClosingElement:
+                case SyntaxKind.JsxSelfClosingElement:
+                    const tagName = (<JsxOpeningElement | JsxClosingElement | JsxSelfClosingElement>node).tagName;
+                    noSubstitution[getOriginalNodeId(tagName)] = true;
+                    break;
+            }
+
+            previousOnEmitNode(emitContext, node, emitCallback);
+        }
+
         /**
          * Hooks node substitutions.
          *
@@ -31,6 +63,10 @@ namespace ts {
          * @param node The node to substitute.
          */
         function onSubstituteNode(emitContext: EmitContext, node: Node) {
+            if (node.id && noSubstitution && noSubstitution[node.id]) {
+                return previousOnSubstituteNode(emitContext, node);
+            }
+
             node = previousOnSubstituteNode(emitContext, node);
             if (isPropertyAccessExpression(node)) {
                 return substitutePropertyAccessExpression(node);

src/compiler/transformers/generators.ts

@@ -938,7 +938,7 @@ namespace ts {
             }
 
             markLabel(resumeLabel);
-            return createGeneratorResume();
+            return createGeneratorResume(/*location*/ node);
         }
 
         /**
@@ -1234,7 +1234,9 @@ namespace ts {
 
         function transformAndEmitVariableDeclarationList(node: VariableDeclarationList): VariableDeclarationList {
             for (const variable of node.declarations) {
-                hoistVariableDeclaration(<Identifier>variable.name);
+                const name = getSynthesizedClone(<Identifier>variable.name);
+                setCommentRange(name, variable.name);
+                hoistVariableDeclaration(name);
             }
 
             const variables = getInitializedVariables(node);
@@ -1287,7 +1289,7 @@ namespace ts {
                 if (containsYield(node.thenStatement) || containsYield(node.elseStatement)) {
                     const endLabel = defineLabel();
                     const elseLabel = node.elseStatement ? defineLabel() : undefined;
-                    emitBreakWhenFalse(node.elseStatement ? elseLabel : endLabel, visitNode(node.expression, visitor, isExpression));
+                    emitBreakWhenFalse(node.elseStatement ? elseLabel : endLabel, visitNode(node.expression, visitor, isExpression), /*location*/ node.expression);
                     transformAndEmitEmbeddedStatement(node.thenStatement);
                     if (node.elseStatement) {
                         emitBreak(endLabel);
@@ -2965,12 +2967,15 @@ namespace ts {
             lastOperationWasAbrupt = true;
             lastOperationWasCompletion = true;
             writeStatement(
-                createReturn(
-                    createArrayLiteral(expression
-                        ? [createInstruction(Instruction.Return), expression]
-                        : [createInstruction(Instruction.Return)]
+                setEmitFlags(
+                    createReturn(
+                        createArrayLiteral(expression
+                            ? [createInstruction(Instruction.Return), expression]
+                            : [createInstruction(Instruction.Return)]
+                        ),
+                        operationLocation
                     ),
-                    operationLocation
+                    EmitFlags.NoTokenSourceMaps
                 )
             );
         }
@@ -2984,12 +2989,15 @@ namespace ts {
         function writeBreak(label: Label, operationLocation: TextRange): void {
             lastOperationWasAbrupt = true;
             writeStatement(
-                createReturn(
-                    createArrayLiteral([
-                        createInstruction(Instruction.Break),
-                        createLabel(label)
-                    ]),
-                    operationLocation
+                setEmitFlags(
+                    createReturn(
+                        createArrayLiteral([
+                            createInstruction(Instruction.Break),
+                            createLabel(label)
+                        ]),
+                        operationLocation
+                    ),
+                    EmitFlags.NoTokenSourceMaps
                 )
             );
         }
@@ -3003,15 +3011,21 @@ namespace ts {
          */
         function writeBreakWhenTrue(label: Label, condition: Expression, operationLocation: TextRange): void {
             writeStatement(
-                createIf(
-                    condition,
-                    createReturn(
-                        createArrayLiteral([
-                            createInstruction(Instruction.Break),
-                            createLabel(label)
-                        ]),
-                        operationLocation
-                    )
+                setEmitFlags(
+                    createIf(
+                        condition,
+                        setEmitFlags(
+                            createReturn(
+                                createArrayLiteral([
+                                    createInstruction(Instruction.Break),
+                                    createLabel(label)
+                                ]),
+                                operationLocation
+                            ),
+                            EmitFlags.NoTokenSourceMaps
+                        )
+                    ),
+                    EmitFlags.SingleLine
                 )
             );
         }
@@ -3025,15 +3039,21 @@ namespace ts {
          */
         function writeBreakWhenFalse(label: Label, condition: Expression, operationLocation: TextRange): void {
             writeStatement(
-                createIf(
-                    createLogicalNot(condition),
-                    createReturn(
-                        createArrayLiteral([
-                            createInstruction(Instruction.Break),
-                            createLabel(label)
-                        ]),
-                        operationLocation
-                    )
+                setEmitFlags(
+                    createIf(
+                        createLogicalNot(condition),
+                        setEmitFlags(
+                            createReturn(
+                                createArrayLiteral([
+                                    createInstruction(Instruction.Break),
+                                    createLabel(label)
+                                ]),
+                                operationLocation
+                            ),
+                            EmitFlags.NoTokenSourceMaps
+                        )
+                    ),
+                    EmitFlags.SingleLine
                 )
             );
         }
@@ -3047,13 +3067,16 @@ namespace ts {
         function writeYield(expression: Expression, operationLocation: TextRange): void {
             lastOperationWasAbrupt = true;
             writeStatement(
-                createReturn(
-                    createArrayLiteral(
-                        expression
-                            ? [createInstruction(Instruction.Yield), expression]
-                            : [createInstruction(Instruction.Yield)]
+                setEmitFlags(
+                    createReturn(
+                        createArrayLiteral(
+                            expression
+                                ? [createInstruction(Instruction.Yield), expression]
+                                : [createInstruction(Instruction.Yield)]
+                        ),
+                        operationLocation
                     ),
-                    operationLocation
+                    EmitFlags.NoTokenSourceMaps
                 )
             );
         }
@@ -3067,12 +3090,15 @@ namespace ts {
         function writeYieldStar(expression: Expression, operationLocation: TextRange): void {
             lastOperationWasAbrupt = true;
             writeStatement(
-                createReturn(
-                    createArrayLiteral([
-                        createInstruction(Instruction.YieldStar),
-                        expression
-                    ]),
-                    operationLocation
+                setEmitFlags(
+                    createReturn(
+                        createArrayLiteral([
+                            createInstruction(Instruction.YieldStar),
+                            expression
+                        ]),
+                        operationLocation
+                    ),
+                    EmitFlags.NoTokenSourceMaps
                 )
             );
         }

src/compiler/transformers/module/module.ts

@@ -102,28 +102,7 @@ namespace ts {
         function transformAMDModule(node: SourceFile) {
             const define = createIdentifier("define");
             const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);
-            return transformAsynchronousModule(node, define, moduleName, /*includeNonAmdDependencies*/ true);
-        }
 
-        /**
-         * Transforms a SourceFile into a UMD module.
-         *
-         * @param node The SourceFile node.
-         */
-        function transformUMDModule(node: SourceFile) {
-            const define = createRawExpression(umdHelper);
-            return transformAsynchronousModule(node, define, /*moduleName*/ undefined, /*includeNonAmdDependencies*/ false);
-        }
-
-        /**
-         * Transforms a SourceFile into an AMD or UMD module.
-         *
-         * @param node The SourceFile node.
-         * @param define The expression used to define the module.
-         * @param moduleName An expression for the module name, if available.
-         * @param includeNonAmdDependencies A value indicating whether to incldue any non-AMD dependencies.
-         */
-        function transformAsynchronousModule(node: SourceFile, define: Expression, moduleName: Expression, includeNonAmdDependencies: boolean) {
             // An AMD define function has the following shape:
             //
             //     define(id?, dependencies?, factory);
@@ -145,7 +124,7 @@ namespace ts {
             //
             // we need to add modules without alias names to the end of the dependencies list
 
-            const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, includeNonAmdDependencies);
+            const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ true);
 
             // Create an updated SourceFile:
             //
@@ -194,6 +173,137 @@ namespace ts {
             );
         }
 
+        /**
+         * Transforms a SourceFile into a UMD module.
+         *
+         * @param node The SourceFile node.
+         */
+        function transformUMDModule(node: SourceFile) {
+            const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ false);
+            const umdHeader = createFunctionExpression(
+                /*modifiers*/ undefined,
+                /*asteriskToken*/ undefined,
+                /*name*/ undefined,
+                /*typeParameters*/ undefined,
+                [createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "factory")],
+                /*type*/ undefined,
+                createBlock(
+                    [
+                        createIf(
+                            createLogicalAnd(
+                                createTypeCheck(createIdentifier("module"), "object"),
+                                createTypeCheck(createPropertyAccess(createIdentifier("module"), "exports"), "object")
+                            ),
+                            createBlock([
+                                createVariableStatement(
+                                    /*modifiers*/ undefined,
+                                    [
+                                        createVariableDeclaration(
+                                            "v",
+                                            /*type*/ undefined,
+                                            createCall(
+                                                createIdentifier("factory"),
+                                                /*typeArguments*/ undefined,
+                                                [
+                                                    createIdentifier("require"),
+                                                    createIdentifier("exports")
+                                                ]
+                                            )
+                                        )
+                                    ]
+                                ),
+                                setEmitFlags(
+                                    createIf(
+                                        createStrictInequality(
+                                            createIdentifier("v"),
+                                            createIdentifier("undefined")
+                                        ),
+                                        createStatement(
+                                            createAssignment(
+                                                createPropertyAccess(createIdentifier("module"), "exports"),
+                                                createIdentifier("v")
+                                            )
+                                        )
+                                    ),
+                                    EmitFlags.SingleLine
+                                )
+                            ]),
+                            createIf(
+                                createLogicalAnd(
+                                    createTypeCheck(createIdentifier("define"), "function"),
+                                    createPropertyAccess(createIdentifier("define"), "amd")
+                                ),
+                                createBlock([
+                                    createStatement(
+                                        createCall(
+                                            createIdentifier("define"),
+                                            /*typeArguments*/ undefined,
+                                            [
+                                                createArrayLiteral([
+                                                    createLiteral("require"),
+                                                    createLiteral("exports"),
+                                                    ...aliasedModuleNames,
+                                                    ...unaliasedModuleNames
+                                                ]),
+                                                createIdentifier("factory")
+                                            ]
+                                        )
+                                    )
+                                ])
+                            )
+                        )
+                    ],
+                    /*location*/ undefined,
+                    /*multiLine*/ true
+                )
+            );
+
+            // Create an updated SourceFile:
+            //
+            //  (function (factory) {
+            //      if (typeof module === "object" && typeof module.exports === "object") {
+            //          var v = factory(require, exports);
+            //          if (v !== undefined) module.exports = v;
+            //      }
+            //      else if (typeof define === 'function' && define.amd) {
+            //          define(["require", "exports"], factory);
+            //      }
+            //  })(function ...)
+
+            return updateSourceFileNode(
+                node,
+                createNodeArray(
+                    [
+                        createStatement(
+                            createCall(
+                                umdHeader,
+                                /*typeArguments*/ undefined,
+                                [
+                                    // Add the module body function argument:
+                                    //
+                                    //     function (require, exports) ...
+                                    createFunctionExpression(
+                                        /*modifiers*/ undefined,
+                                        /*asteriskToken*/ undefined,
+                                        /*name*/ undefined,
+                                        /*typeParameters*/ undefined,
+                                        [
+                                            createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"),
+                                            createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports"),
+                                            ...importAliasNames
+                                        ],
+                                        /*type*/ undefined,
+                                        transformAsynchronousModuleBody(node)
+                                    )
+                                ]
+                            )
+                        )
+                    ],
+                    /*location*/ node.statements
+                )
+            );
+        }
+
         /**
          * Collect the additional asynchronous dependencies for the module.
          *
@@ -1333,15 +1443,4 @@ namespace ts {
                 for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
             }`
     };
-
-    // emit output for the UMD helper function.
-    const umdHelper = `
-        (function (dependencies, factory) {
-            if (typeof module === 'object' && typeof module.exports === 'object') {
-                var v = factory(require, exports); if (v !== undefined) module.exports = v;
-            }
-            else if (typeof define === 'function' && define.amd) {
-                define(dependencies, factory);
-            }
-        })`;
 }

src/compiler/transformers/module/system.ts

@@ -101,20 +101,21 @@ namespace ts {
             // So the helper will be emit at the correct position instead of at the top of the source-file
             const moduleName = tryGetModuleNameFromFile(node, host, compilerOptions);
             const dependencies = createArrayLiteral(map(dependencyGroups, dependencyGroup => dependencyGroup.name));
-            const updated = updateSourceFileNode(
-                node,
-                createNodeArray([
-                    createStatement(
-                        createCall(
-                            createPropertyAccess(createIdentifier("System"), "register"),
+            const updated = setEmitFlags(
+                updateSourceFileNode(
+                    node,
+                    createNodeArray([
+                        createStatement(
+                            createCall(
+                                createPropertyAccess(createIdentifier("System"), "register"),
                             /*typeArguments*/ undefined,
-                            moduleName
-                                ? [moduleName, dependencies, moduleBodyFunction]
-                                : [dependencies, moduleBodyFunction]
+                                moduleName
+                                    ? [moduleName, dependencies, moduleBodyFunction]
+                                    : [dependencies, moduleBodyFunction]
+                            )
                         )
-                    )
-                ], node.statements)
-            );
+                    ], node.statements)
+                ), EmitFlags.NoTrailingComments);
 
             if (!(compilerOptions.outFile || compilerOptions.out)) {
                 moveEmitHelpers(updated, moduleBodyBlock, helper => !helper.scoped);

src/compiler/transformers/ts.ts

@@ -1277,7 +1277,7 @@ namespace ts {
          * @param node The declaration node.
          * @param allDecorators An object containing all of the decorators for the declaration.
          */
-        function transformAllDecoratorsOfDeclaration(node: Declaration, allDecorators: AllDecorators) {
+        function transformAllDecoratorsOfDeclaration(node: Declaration, container: ClassLikeDeclaration, allDecorators: AllDecorators) {
             if (!allDecorators) {
                 return undefined;
             }
@@ -1285,7 +1285,7 @@ namespace ts {
             const decoratorExpressions: Expression[] = [];
             addRange(decoratorExpressions, map(allDecorators.decorators, transformDecorator));
             addRange(decoratorExpressions, flatMap(allDecorators.parameters, transformDecoratorsOfParameter));
-            addTypeMetadata(node, decoratorExpressions);
+            addTypeMetadata(node, container, decoratorExpressions);
             return decoratorExpressions;
         }
 
@@ -1334,7 +1334,7 @@ namespace ts {
          */
         function generateClassElementDecorationExpression(node: ClassExpression | ClassDeclaration, member: ClassElement) {
             const allDecorators = getAllDecoratorsOfClassElement(node, member);
-            const decoratorExpressions = transformAllDecoratorsOfDeclaration(member, allDecorators);
+            const decoratorExpressions = transformAllDecoratorsOfDeclaration(member, node, allDecorators);
             if (!decoratorExpressions) {
                 return undefined;
             }
@@ -1415,7 +1415,7 @@ namespace ts {
          */
         function generateConstructorDecorationExpression(node: ClassExpression | ClassDeclaration) {
             const allDecorators = getAllDecoratorsOfConstructor(node);
-            const decoratorExpressions = transformAllDecoratorsOfDeclaration(node, allDecorators);
+            const decoratorExpressions = transformAllDecoratorsOfDeclaration(node, node, allDecorators);
             if (!decoratorExpressions) {
                 return undefined;
             }
@@ -1468,22 +1468,22 @@ namespace ts {
          * @param node The declaration node.
          * @param decoratorExpressions The destination array to which to add new decorator expressions.
          */
-        function addTypeMetadata(node: Declaration, decoratorExpressions: Expression[]) {
+        function addTypeMetadata(node: Declaration, container: ClassLikeDeclaration, decoratorExpressions: Expression[]) {
             if (USE_NEW_TYPE_METADATA_FORMAT) {
-                addNewTypeMetadata(node, decoratorExpressions);
+                addNewTypeMetadata(node, container, decoratorExpressions);
             }
             else {
-                addOldTypeMetadata(node, decoratorExpressions);
+                addOldTypeMetadata(node, container, decoratorExpressions);
             }
         }
 
-        function addOldTypeMetadata(node: Declaration, decoratorExpressions: Expression[]) {
+        function addOldTypeMetadata(node: Declaration, container: ClassLikeDeclaration, decoratorExpressions: Expression[]) {
             if (compilerOptions.emitDecoratorMetadata) {
                 if (shouldAddTypeMetadata(node)) {
                     decoratorExpressions.push(createMetadataHelper(context, "design:type", serializeTypeOfNode(node)));
                 }
                 if (shouldAddParamTypesMetadata(node)) {
-                    decoratorExpressions.push(createMetadataHelper(context, "design:paramtypes", serializeParameterTypesOfNode(node)));
+                    decoratorExpressions.push(createMetadataHelper(context, "design:paramtypes", serializeParameterTypesOfNode(node, container)));
                 }
                 if (shouldAddReturnTypeMetadata(node)) {
                     decoratorExpressions.push(createMetadataHelper(context, "design:returntype", serializeReturnTypeOfNode(node)));
@@ -1491,14 +1491,14 @@ namespace ts {
             }
         }
 
-        function addNewTypeMetadata(node: Declaration, decoratorExpressions: Expression[]) {
+        function addNewTypeMetadata(node: Declaration, container: ClassLikeDeclaration, decoratorExpressions: Expression[]) {
             if (compilerOptions.emitDecoratorMetadata) {
                 let properties: ObjectLiteralElementLike[];
                 if (shouldAddTypeMetadata(node)) {
                     (properties || (properties = [])).push(createPropertyAssignment("type", createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, createToken(SyntaxKind.EqualsGreaterThanToken), serializeTypeOfNode(node))));
                 }
                 if (shouldAddParamTypesMetadata(node)) {
-                    (properties || (properties = [])).push(createPropertyAssignment("paramTypes", createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, createToken(SyntaxKind.EqualsGreaterThanToken), serializeParameterTypesOfNode(node))));
+                    (properties || (properties = [])).push(createPropertyAssignment("paramTypes", createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, createToken(SyntaxKind.EqualsGreaterThanToken), serializeParameterTypesOfNode(node, container))));
                 }
                 if (shouldAddReturnTypeMetadata(node)) {
                     (properties || (properties = [])).push(createPropertyAssignment("returnType", createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, createToken(SyntaxKind.EqualsGreaterThanToken), serializeReturnTypeOfNode(node))));
@@ -1543,20 +1543,27 @@ namespace ts {
          * @param node The node to test.
          */
         function shouldAddParamTypesMetadata(node: Declaration): boolean {
-            const kind = node.kind;
-            return kind === SyntaxKind.ClassDeclaration
-                || kind === SyntaxKind.ClassExpression
-                || kind === SyntaxKind.MethodDeclaration
-                || kind === SyntaxKind.GetAccessor
-                || kind === SyntaxKind.SetAccessor;
+            switch (node.kind) {
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.ClassExpression:
+                    return getFirstConstructorWithBody(<ClassLikeDeclaration>node) !== undefined;
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return true;
+            }
+            return false;
         }
 
+        type SerializedEntityNameAsExpression = Identifier | BinaryExpression | PropertyAccessExpression;
+        type SerializedTypeNode = SerializedEntityNameAsExpression | VoidExpression | ConditionalExpression;
+
         /**
          * Serializes the type of a node for use with decorator type metadata.
          *
          * @param node The node that should have its type serialized.
          */
-        function serializeTypeOfNode(node: Node): Expression {
+        function serializeTypeOfNode(node: Node): SerializedTypeNode {
             switch (node.kind) {
                 case SyntaxKind.PropertyDeclaration:
                 case SyntaxKind.Parameter:
@@ -1573,30 +1580,12 @@ namespace ts {
             }
         }
 
-        /**
-         * Gets the most likely element type for a TypeNode. This is not an exhaustive test
-         * as it assumes a rest argument can only be an array type (either T[], or Array<T>).
-         *
-         * @param node The type node.
-         */
-        function getRestParameterElementType(node: TypeNode) {
-            if (node && node.kind === SyntaxKind.ArrayType) {
-                return (<ArrayTypeNode>node).elementType;
-            }
-            else if (node && node.kind === SyntaxKind.TypeReference) {
-                return singleOrUndefined((<TypeReferenceNode>node).typeArguments);
-            }
-            else {
-                return undefined;
-            }
-        }
-
         /**
          * Serializes the types of the parameters of a node for use with decorator type metadata.
          *
          * @param node The node that should have its parameter types serialized.
          */
-        function serializeParameterTypesOfNode(node: Node): Expression {
+        function serializeParameterTypesOfNode(node: Node, container: ClassLikeDeclaration): ArrayLiteralExpression {
             const valueDeclaration =
                 isClassLike(node)
                     ? getFirstConstructorWithBody(node)
@@ -1604,9 +1593,9 @@ namespace ts {
                         ? node
                         : undefined;
 
-            const expressions: Expression[] = [];
+            const expressions: SerializedTypeNode[] = [];
             if (valueDeclaration) {
-                const parameters = valueDeclaration.parameters;
+                const parameters = getParametersOfDecoratedDeclaration(valueDeclaration, container);
                 const numParameters = parameters.length;
                 for (let i = 0; i < numParameters; i++) {
                     const parameter = parameters[i];
@@ -1625,12 +1614,22 @@ namespace ts {
             return createArrayLiteral(expressions);
         }
 
+        function getParametersOfDecoratedDeclaration(node: FunctionLikeDeclaration, container: ClassLikeDeclaration) {
+            if (container && node.kind === SyntaxKind.GetAccessor) {
+                const { setAccessor } = getAllAccessorDeclarations(container.members, <AccessorDeclaration>node);
+                if (setAccessor) {
+                    return setAccessor.parameters;
+                }
+            }
+            return node.parameters;
+        }
+
         /**
          * Serializes the return type of a node for use with decorator type metadata.
          *
          * @param node The node that should have its return type serialized.
          */
-        function serializeReturnTypeOfNode(node: Node): Expression {
+        function serializeReturnTypeOfNode(node: Node): SerializedTypeNode {
             if (isFunctionLike(node) && node.type) {
                 return serializeTypeNode(node.type);
             }
@@ -1659,13 +1658,16 @@ namespace ts {
          *
          * @param node The type node to serialize.
          */
-        function serializeTypeNode(node: TypeNode): Expression {
+        function serializeTypeNode(node: TypeNode): SerializedTypeNode {
             if (node === undefined) {
                 return createIdentifier("Object");
             }
 
             switch (node.kind) {
                 case SyntaxKind.VoidKeyword:
+                case SyntaxKind.UndefinedKeyword:
+                case SyntaxKind.NullKeyword:
+                case SyntaxKind.NeverKeyword:
                     return createVoidZero();
 
                 case SyntaxKind.ParenthesizedType:
@@ -1717,37 +1719,8 @@ namespace ts {
 
                 case SyntaxKind.IntersectionType:
                 case SyntaxKind.UnionType:
-                    {
-                        const unionOrIntersection = <UnionOrIntersectionTypeNode>node;
-                        let serializedUnion: Identifier;
-                        for (const typeNode of unionOrIntersection.types) {
-                            const serializedIndividual = serializeTypeNode(typeNode) as Identifier;
-                            // Non identifier
-                            if (serializedIndividual.kind !== SyntaxKind.Identifier) {
-                                serializedUnion = undefined;
-                                break;
-                            }
+                    return serializeUnionOrIntersectionType(<UnionOrIntersectionTypeNode>node);
 
-                            // One of the individual is global object, return immediately
-                            if (serializedIndividual.text === "Object") {
-                                return serializedIndividual;
-                            }
-
-                            // Different types
-                            if (serializedUnion && serializedUnion.text !== serializedIndividual.text) {
-                                serializedUnion = undefined;
-                                break;
-                            }
-
-                            serializedUnion = serializedIndividual;
-                        }
-
-                        // If we were able to find common type
-                        if (serializedUnion) {
-                            return serializedUnion;
-                        }
-                    }
-                    // Fallthrough
                 case SyntaxKind.TypeQuery:
                 case SyntaxKind.TypeOperator:
                 case SyntaxKind.IndexedAccessType:
@@ -1765,13 +1738,48 @@ namespace ts {
             return createIdentifier("Object");
         }
 
+        function serializeUnionOrIntersectionType(node: UnionOrIntersectionTypeNode): SerializedTypeNode {
+            let serializedUnion: SerializedTypeNode;
+            for (const typeNode of node.types) {
+                const serializedIndividual = serializeTypeNode(typeNode);
+
+                if (isVoidExpression(serializedIndividual)) {
+                    // If we dont have any other type already set, set the initial type
+                    if (!serializedUnion) {
+                        serializedUnion = serializedIndividual;
+                    }
+                }
+                else if (isIdentifier(serializedIndividual) && serializedIndividual.text === "Object") {
+                    // One of the individual is global object, return immediately
+                    return serializedIndividual;
+                }
+                // If there exists union that is not void 0 expression, check if the the common type is identifier.
+                // anything more complex and we will just default to Object
+                else if (serializedUnion && !isVoidExpression(serializedUnion)) {
+                    // Different types
+                    if (!isIdentifier(serializedUnion) ||
+                        !isIdentifier(serializedIndividual) ||
+                        serializedUnion.text !== serializedIndividual.text) {
+                        return createIdentifier("Object");
+                    }
+                }
+                else {
+                    // Initialize the union type
+                    serializedUnion = serializedIndividual;
+                }
+            }
+
+            // If we were able to find common type, use it
+            return serializedUnion;
+        }
+
         /**
          * Serializes a TypeReferenceNode to an appropriate JS constructor value for use with
          * decorator type metadata.
          *
          * @param node The type reference node.
          */
-        function serializeTypeReferenceNode(node: TypeReferenceNode) {
+        function serializeTypeReferenceNode(node: TypeReferenceNode): SerializedTypeNode {
             switch (resolver.getTypeReferenceSerializationKind(node.typeName, currentScope)) {
                 case TypeReferenceSerializationKind.Unknown:
                     const serialized = serializeEntityNameAsExpression(node.typeName, /*useFallback*/ true);
@@ -1826,7 +1834,7 @@ namespace ts {
          * @param useFallback A value indicating whether to use logical operators to test for the
          *                    entity name at runtime.
          */
-        function serializeEntityNameAsExpression(node: EntityName, useFallback: boolean): Expression {
+        function serializeEntityNameAsExpression(node: EntityName, useFallback: boolean): SerializedEntityNameAsExpression {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
                     // Create a clone of the name with a new parent, and treat it as if it were
@@ -1859,8 +1867,8 @@ namespace ts {
          * @param useFallback A value indicating whether to use logical operators to test for the
          *                    qualified name at runtime.
          */
-        function serializeQualifiedNameAsExpression(node: QualifiedName, useFallback: boolean): Expression {
-            let left: Expression;
+        function serializeQualifiedNameAsExpression(node: QualifiedName, useFallback: boolean): PropertyAccessExpression {
+            let left: SerializedEntityNameAsExpression;
             if (node.left.kind === SyntaxKind.Identifier) {
                 left = serializeEntityNameAsExpression(node.left, useFallback);
             }
@@ -1885,7 +1893,7 @@ namespace ts {
          * Gets an expression that points to the global "Symbol" constructor at runtime if it is
          * available.
          */
-        function getGlobalSymbolNameWithFallback(): Expression {
+        function getGlobalSymbolNameWithFallback(): ConditionalExpression {
             return createConditional(
                 createTypeCheck(createIdentifier("Symbol"), "function"),
                 createIdentifier("Symbol"),
@@ -2723,7 +2731,7 @@ namespace ts {
             let blockLocation: TextRange;
             const body = node.body;
             if (body.kind === SyntaxKind.ModuleBlock) {
-                addRange(statements, visitNodes((<ModuleBlock>body).statements, namespaceElementVisitor, isStatement));
+                saveStateAndInvoke(body, body => addRange(statements, visitNodes((<ModuleBlock>body).statements, namespaceElementVisitor, isStatement)));
                 statementsLocation = (<ModuleBlock>body).statements;
                 blockLocation = body;
             }

src/compiler/types.ts

@@ -253,6 +253,7 @@ namespace ts {
         ExpressionWithTypeArguments,
         AsExpression,
         NonNullExpression,
+        MetaProperty,
 
         // Misc
         TemplateSpan,
@@ -370,7 +371,6 @@ namespace ts {
         PartiallyEmittedExpression,
         MergeDeclarationMarker,
         EndOfDeclarationMarker,
-        RawExpression,
 
         // Enum value count
         Count,
@@ -640,9 +640,9 @@ namespace ts {
 
     export interface ParameterDeclaration extends Declaration {
         kind: SyntaxKind.Parameter;
-        dotDotDotToken?: DotDotDotToken;              // Present on rest parameter
+        dotDotDotToken?: DotDotDotToken;    // Present on rest parameter
         name: BindingName;                  // Declared parameter name
-        questionToken?: QuestionToken;               // Present on optional parameter
+        questionToken?: QuestionToken;      // Present on optional parameter
         type?: TypeNode;                    // Optional type annotation
         initializer?: Expression;           // Optional initializer
     }
@@ -658,14 +658,14 @@ namespace ts {
     export interface PropertySignature extends TypeElement {
         kind: SyntaxKind.PropertySignature | SyntaxKind.JSDocRecordMember;
         name: PropertyName;                 // Declared property name
-        questionToken?: QuestionToken;               // Present on optional property
+        questionToken?: QuestionToken;      // Present on optional property
         type?: TypeNode;                    // Optional type annotation
         initializer?: Expression;           // Optional initializer
     }
 
     export interface PropertyDeclaration extends ClassElement {
         kind: SyntaxKind.PropertyDeclaration;
-        questionToken?: QuestionToken;               // Present for use with reporting a grammar error
+        questionToken?: QuestionToken;      // Present for use with reporting a grammar error
         name: PropertyName;
         type?: TypeNode;
         initializer?: Expression;           // Optional initializer
@@ -1444,6 +1444,14 @@ namespace ts {
         expression: Expression;
     }
 
+    // NOTE: MetaProperty is really a MemberExpression, but we consider it a PrimaryExpression
+    //       for the same reasons we treat NewExpression as a PrimaryExpression.
+    export interface MetaProperty extends PrimaryExpression {
+        kind: SyntaxKind.MetaProperty;
+        keywordToken: SyntaxKind;
+        name: Identifier;
+    }
+
     /// A JSX expression of the form <TagName attrs>...</TagName>
     export interface JsxElement extends PrimaryExpression {
         kind: SyntaxKind.JsxElement;
@@ -1492,6 +1500,7 @@ namespace ts {
 
     export interface JsxExpression extends Expression {
         kind: SyntaxKind.JsxExpression;
+        dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
         expression?: Expression;
     }
 
@@ -1520,16 +1529,6 @@ namespace ts {
         kind: SyntaxKind.EndOfDeclarationMarker;
     }
 
-    /**
-     * Emits a string of raw text in an expression position. Raw text is never transformed, should
-     * be ES3 compliant, and should have the same precedence as PrimaryExpression.
-     */
-    /* @internal */
-    export interface RawExpression extends PrimaryExpression {
-        kind: SyntaxKind.RawExpression;
-        text: string;
-    }
-
     /**
      * Marks the beginning of a merged transformed declaration.
      */
@@ -2335,6 +2334,7 @@ namespace ts {
         getDeclaredTypeOfSymbol(symbol: Symbol): Type;
         getPropertiesOfType(type: Type): Symbol[];
         getPropertyOfType(type: Type, propertyName: string): Symbol;
+        getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo;
         getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
         getIndexTypeOfType(type: Type, kind: IndexKind): Type;
         getBaseTypes(type: InterfaceType): ObjectType[];
@@ -2348,6 +2348,8 @@ namespace ts {
         getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol;
         getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol;
         getTypeAtLocation(node: Node): Type;
+        getTypeFromTypeNode(node: TypeNode): Type;
+        signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
         getSymbolDisplayBuilder(): SymbolDisplayBuilder;
@@ -2373,6 +2375,7 @@ namespace ts {
         getAmbientModules(): Symbol[];
 
         tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
+        getApparentType(type: Type): Type;
 
         /* @internal */ tryFindAmbientModuleWithoutAugmentations(moduleName: string): Symbol;
 
@@ -2391,6 +2394,7 @@ namespace ts {
         buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
         buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): void;
+        buildIndexSignatureDisplay(info: IndexInfo, writer: SymbolWriter, kind: IndexKind, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, symbolStack?: Symbol[]): void;
         buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         buildTypePredicateDisplay(predicate: TypePredicate, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
@@ -2434,6 +2438,7 @@ namespace ts {
         InFirstTypeArgument             = 0x00000100,  // Writing first type argument of the instantiated type
         InTypeAlias                     = 0x00000200,  // Writing type in type alias declaration
         UseTypeAliasValue               = 0x00000400,  // Serialize the type instead of using type-alias. This is needed when we emit declaration file.
+        SuppressAnyReturnType            = 0x00000800,  // If the return type is any-like, don't offer a return type.
     }
 
     export const enum SymbolFormatFlags {
@@ -2713,6 +2718,7 @@ namespace ts {
         TypeChecked                         = 0x00000001,  // Node has been type checked
         LexicalThis                         = 0x00000002,  // Lexical 'this' reference
         CaptureThis                         = 0x00000004,  // Lexical 'this' used in body
+        CaptureNewTarget                    = 0x00000008,  // Lexical 'new.target' used in body
         SuperInstance                       = 0x00000100,  // Instance 'super' reference
         SuperStatic                         = 0x00000200,  // Static 'super' reference
         ContextChecked                      = 0x00000400,  // Contextual types have been assigned
@@ -2865,7 +2871,7 @@ namespace ts {
         objectFlags: ObjectFlags;
     }
 
-    // Class and interface types (TypeFlags.Class and TypeFlags.Interface)
+    /** Class and interface types (TypeFlags.Class and TypeFlags.Interface). */
     export interface InterfaceType extends ObjectType {
         typeParameters: TypeParameter[];           // Type parameters (undefined if non-generic)
         outerTypeParameters: TypeParameter[];      // Outer type parameters (undefined if none)
@@ -2885,14 +2891,16 @@ namespace ts {
         declaredNumberIndexInfo: IndexInfo;        // Declared numeric indexing info
     }
 
-    // Type references (TypeFlags.Reference). When a class or interface has type parameters or
-    // a "this" type, references to the class or interface are made using type references. The
-    // typeArguments property specifies the types to substitute for the type parameters of the
-    // class or interface and optionally includes an extra element that specifies the type to
-    // substitute for "this" in the resulting instantiation. When no extra argument is present,
-    // the type reference itself is substituted for "this". The typeArguments property is undefined
-    // if the class or interface has no type parameters and the reference isn't specifying an
-    // explicit "this" argument.
+    /**
+     * Type references (TypeFlags.Reference). When a class or interface has type parameters or
+     * a "this" type, references to the class or interface are made using type references. The
+     * typeArguments property specifies the types to substitute for the type parameters of the
+     * class or interface and optionally includes an extra element that specifies the type to
+     * substitute for "this" in the resulting instantiation. When no extra argument is present,
+     * the type reference itself is substituted for "this". The typeArguments property is undefined
+     * if the class or interface has no type parameters and the reference isn't specifying an
+     * explicit "this" argument.
+     */
     export interface TypeReference extends ObjectType {
         target: GenericType;    // Type reference target
         typeArguments: Type[];  // Type reference type arguments (undefined if none)
@@ -2933,6 +2941,7 @@ namespace ts {
         typeParameter?: TypeParameter;
         constraintType?: Type;
         templateType?: Type;
+        modifiersType?: Type;
         mapper?: TypeMapper;  // Instantiation mapper
     }
 
@@ -2968,6 +2977,8 @@ namespace ts {
     }
 
     export interface TypeVariable extends Type {
+        /* @internal */
+        resolvedApparentType: Type;
         /* @internal */
         resolvedIndexType: IndexType;
     }
@@ -2980,8 +2991,6 @@ namespace ts {
         /* @internal */
         mapper?: TypeMapper;     // Instantiation mapper
         /* @internal */
-        resolvedApparentType: Type;
-        /* @internal */
         isThisType?: boolean;
     }
 
@@ -2990,6 +2999,7 @@ namespace ts {
     export interface IndexedAccessType extends TypeVariable {
         objectType: Type;
         indexType: Type;
+        constraint?: Type;
     }
 
     // keyof T types (TypeFlags.Index)
@@ -3086,6 +3096,12 @@ namespace ts {
         ThisProperty
     }
 
+    export interface FileExtensionInfo {
+        extension: string;
+        scriptKind: ScriptKind;
+        isMixedContent: boolean;
+    }
+
     export interface DiagnosticMessage {
         key: string;
         category: DiagnosticCategory;
@@ -3535,6 +3551,7 @@ namespace ts {
 
     export interface ResolvedModuleWithFailedLookupLocations {
         resolvedModule: ResolvedModuleFull | undefined;
+        /* @internal */
         failedLookupLocations: string[];
     }
 

src/compiler/utilities.ts

@@ -1,4 +1,4 @@
-/// <reference path="sys.ts" />
+/// <reference path="sys.ts" />
 
 /* @internal */
 namespace ts {
@@ -550,7 +550,7 @@ namespace ts {
         let errorNode = node;
         switch (node.kind) {
             case SyntaxKind.SourceFile:
-                let pos = skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);
+                const pos = skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false);
                 if (pos === sourceFile.text.length) {
                     // file is empty - return span for the beginning of the file
                     return createTextSpan(0, 0);
@@ -682,7 +682,7 @@ namespace ts {
             case SyntaxKind.QualifiedName:
             case SyntaxKind.PropertyAccessExpression:
             case SyntaxKind.ThisKeyword:
-                let parent = node.parent;
+                const parent = node.parent;
                 if (parent.kind === SyntaxKind.TypeQuery) {
                     return false;
                 }
@@ -732,6 +732,20 @@ namespace ts {
         return false;
     }
 
+    export function isChildOfNodeWithKind(node: Node, kind: SyntaxKind): boolean {
+        while (node) {
+            if (node.kind === kind) {
+                return true;
+            }
+            node = node.parent;
+        }
+        return false;
+    }
+
+    export function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression {
+        return node.kind === SyntaxKind.PrefixUnaryExpression;
+    }
+
     // Warning: This has the same semantics as the forEach family of functions,
     //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
     export function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {
@@ -770,7 +784,7 @@ namespace ts {
             switch (node.kind) {
                 case SyntaxKind.YieldExpression:
                     visitor(<YieldExpression>node);
-                    let operand = (<YieldExpression>node).expression;
+                    const operand = (<YieldExpression>node).expression;
                     if (operand) {
                         traverse(operand);
                     }
@@ -803,6 +817,23 @@ namespace ts {
         }
     }
 
+    /**
+     * Gets the most likely element type for a TypeNode. This is not an exhaustive test
+     * as it assumes a rest argument can only be an array type (either T[], or Array<T>).
+     *
+     * @param node The type node.
+     */
+    export function getRestParameterElementType(node: TypeNode) {
+        if (node && node.kind === SyntaxKind.ArrayType) {
+            return (<ArrayTypeNode>node).elementType;
+        }
+        else if (node && node.kind === SyntaxKind.TypeReference) {
+            return singleOrUndefined((<TypeReferenceNode>node).typeArguments);
+        }
+        else {
+            return undefined;
+        }
+    }
 
     export function isVariableLike(node: Node): node is VariableLikeDeclaration {
         if (node) {
@@ -883,6 +914,17 @@ namespace ts {
         return false;
     }
 
+    export function unwrapInnermostStatmentOfLabel(node: LabeledStatement, beforeUnwrapLabelCallback?: (node: LabeledStatement) => void) {
+        while (true) {
+            if (beforeUnwrapLabelCallback) {
+                beforeUnwrapLabelCallback(node);
+            }
+            if (node.statement.kind !== SyntaxKind.LabeledStatement) {
+                return node.statement;
+            }
+            node = <LabeledStatement>node.statement;
+        }
+    }
 
     export function isFunctionBlock(node: Node) {
         return node && node.kind === SyntaxKind.Block && isFunctionLike(node.parent);
@@ -984,6 +1026,20 @@ namespace ts {
         }
     }
 
+    export function getNewTargetContainer(node: Node) {
+        const container = getThisContainer(node, /*includeArrowFunctions*/ false);
+        if (container) {
+            switch (container.kind) {
+                case SyntaxKind.Constructor:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.FunctionExpression:
+                    return container;
+            }
+        }
+
+        return undefined;
+    }
+
     /**
       * Given an super call/property node, returns the closest node where
       * - a super call/property access is legal in the node and not legal in the parent node the node.
@@ -1191,6 +1247,7 @@ namespace ts {
             case SyntaxKind.JsxSelfClosingElement:
             case SyntaxKind.YieldExpression:
             case SyntaxKind.AwaitExpression:
+            case SyntaxKind.MetaProperty:
                 return true;
             case SyntaxKind.QualifiedName:
                 while (node.parent.kind === SyntaxKind.QualifiedName) {
@@ -1205,7 +1262,7 @@ namespace ts {
             case SyntaxKind.NumericLiteral:
             case SyntaxKind.StringLiteral:
             case SyntaxKind.ThisKeyword:
-                let parent = node.parent;
+                const parent = node.parent;
                 switch (parent.kind) {
                     case SyntaxKind.VariableDeclaration:
                     case SyntaxKind.Parameter:
@@ -1227,13 +1284,13 @@ namespace ts {
                     case SyntaxKind.SwitchStatement:
                         return (<ExpressionStatement>parent).expression === node;
                     case SyntaxKind.ForStatement:
-                        let forStatement = <ForStatement>parent;
+                        const forStatement = <ForStatement>parent;
                         return (forStatement.initializer === node && forStatement.initializer.kind !== SyntaxKind.VariableDeclarationList) ||
                             forStatement.condition === node ||
                             forStatement.incrementor === node;
                     case SyntaxKind.ForInStatement:
                     case SyntaxKind.ForOfStatement:
-                        let forInStatement = <ForInStatement | ForOfStatement>parent;
+                        const forInStatement = <ForInStatement | ForOfStatement>parent;
                         return (forInStatement.initializer === node && forInStatement.initializer.kind !== SyntaxKind.VariableDeclarationList) ||
                             forInStatement.expression === node;
                     case SyntaxKind.TypeAssertionExpression:
@@ -1626,6 +1683,18 @@ namespace ts {
         return getAssignmentTargetKind(node) !== AssignmentKind.None;
     }
 
+    // a node is delete target iff. it is PropertyAccessExpression/ElementAccessExpression with parentheses skipped
+    export function isDeleteTarget(node: Node): boolean {
+        if (node.kind !== SyntaxKind.PropertyAccessExpression && node.kind !== SyntaxKind.ElementAccessExpression) {
+            return false;
+        }
+        node = node.parent;
+        while (node && node.kind === SyntaxKind.ParenthesizedExpression) {
+            node = node.parent;
+        }
+        return node && node.kind === SyntaxKind.DeleteExpression;
+    }
+
     export function isNodeDescendantOf(node: Node, ancestor: Node): boolean {
         while (node) {
             if (node === ancestor) return true;
@@ -1761,7 +1830,7 @@ namespace ts {
         }
     }
 
-    export function getAncestor(node: Node, kind: SyntaxKind): Node {
+    export function getAncestor(node: Node | undefined, kind: SyntaxKind): Node {
         while (node) {
             if (node.kind === kind) {
                 return node;
@@ -2087,7 +2156,6 @@ namespace ts {
             case SyntaxKind.TemplateExpression:
             case SyntaxKind.ParenthesizedExpression:
             case SyntaxKind.OmittedExpression:
-            case SyntaxKind.RawExpression:
                 return 19;
 
             case SyntaxKind.TaggedTemplateExpression:
@@ -2311,13 +2379,11 @@ namespace ts {
      * Note that this doesn't actually wrap the input in double quotes.
      */
     export function escapeString(s: string): string {
-        s = escapedCharsRegExp.test(s) ? s.replace(escapedCharsRegExp, getReplacement) : s;
+        return s.replace(escapedCharsRegExp, getReplacement);
+    }
 
-        return s;
-
-        function getReplacement(c: string) {
-            return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
-        }
+    function getReplacement(c: string) {
+        return escapedCharsMap[c] || get16BitUnicodeEscapeSequence(c.charCodeAt(0));
     }
 
     export function isIntrinsicJsxName(name: string) {
@@ -3189,55 +3255,6 @@ namespace ts {
         return output;
     }
 
-    /**
-     * Serialize an object graph into a JSON string. This is intended only for use on an acyclic graph
-     * as the fallback implementation does not check for circular references by default.
-     */
-    export const stringify: (value: any) => string = typeof JSON !== "undefined" && JSON.stringify
-        ? JSON.stringify
-        : stringifyFallback;
-
-    /**
-     * Serialize an object graph into a JSON string.
-     */
-    function stringifyFallback(value: any): string {
-        // JSON.stringify returns `undefined` here, instead of the string "undefined".
-        return value === undefined ? undefined : stringifyValue(value);
-    }
-
-    function stringifyValue(value: any): string {
-        return typeof value === "string" ? `"${escapeString(value)}"`
-            : typeof value === "number" ? isFinite(value) ? String(value) : "null"
-                : typeof value === "boolean" ? value ? "true" : "false"
-                    : typeof value === "object" && value ? isArray(value) ? cycleCheck(stringifyArray, value) : cycleCheck(stringifyObject, value)
-                        : /*fallback*/ "null";
-    }
-
-    function cycleCheck(cb: (value: any) => string, value: any) {
-        Debug.assert(!value.hasOwnProperty("__cycle"), "Converting circular structure to JSON");
-        value.__cycle = true;
-        const result = cb(value);
-        delete value.__cycle;
-        return result;
-    }
-
-    function stringifyArray(value: any) {
-        return `[${reduceLeft(value, stringifyElement, "")}]`;
-    }
-
-    function stringifyElement(memo: string, value: any) {
-        return (memo ? memo + "," : memo) + stringifyValue(value);
-    }
-
-    function stringifyObject(value: any) {
-        return `{${reduceOwnProperties(value, stringifyProperty, "")}}`;
-    }
-
-    function stringifyProperty(memo: string, value: any, key: string) {
-        return value === undefined || typeof value === "function" || key === "__cycle" ? memo
-            : (memo ? memo + "," : memo) + `"${escapeString(key)}":${stringifyValue(value)}`;
-    }
-
     const base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 
     /**
@@ -3613,6 +3630,10 @@ namespace ts {
         return node.kind === SyntaxKind.Identifier;
     }
 
+    export function isVoidExpression(node: Node): node is VoidExpression {
+        return node.kind === SyntaxKind.VoidExpression;
+    }
+
     export function isGeneratedIdentifier(node: Node): node is GeneratedIdentifier {
         // Using `>` here catches both `GeneratedIdentifierKind.None` and `undefined`.
         return isIdentifier(node) && node.autoGenerateKind > GeneratedIdentifierKind.None;
@@ -3880,7 +3901,7 @@ namespace ts {
             || kind === SyntaxKind.TrueKeyword
             || kind === SyntaxKind.SuperKeyword
             || kind === SyntaxKind.NonNullExpression
-            || kind === SyntaxKind.RawExpression;
+            || kind === SyntaxKind.MetaProperty;
     }
 
     export function isLeftHandSideExpression(node: Node): node is LeftHandSideExpression {
@@ -3910,7 +3931,6 @@ namespace ts {
             || kind === SyntaxKind.SpreadElement
             || kind === SyntaxKind.AsExpression
             || kind === SyntaxKind.OmittedExpression
-            || kind === SyntaxKind.RawExpression
             || isUnaryExpressionKind(kind);
     }
 

src/compiler/visitor.ts

@@ -1328,7 +1328,7 @@ namespace ts {
     function aggregateTransformFlagsForSubtree(node: Node): TransformFlags {
         // We do not transform ambient declarations or types, so there is no need to
         // recursively aggregate transform flags.
-        if (hasModifier(node, ModifierFlags.Ambient) || isTypeNode(node)) {
+        if (hasModifier(node, ModifierFlags.Ambient) || (isTypeNode(node) && node.kind !== SyntaxKind.ExpressionWithTypeArguments)) {
             return TransformFlags.None;
         }
 

src/harness/fourslash.ts

@@ -44,6 +44,14 @@ namespace FourSlash {
 
         markers: Marker[];
 
+        /**
+         * Inserted in source files by surrounding desired text
+         * in a range with `[|` and `|]`. For example,
+         * 
+         * [|text in range|]
+         * 
+         * is a range with `text in range` "selected".
+         */
         ranges: Range[];
     }
 
@@ -341,6 +349,7 @@ namespace FourSlash {
                 insertSpaceAfterCommaDelimiter: true,
                 insertSpaceAfterSemicolonInForStatements: true,
                 insertSpaceBeforeAndAfterBinaryOperators: true,
+                insertSpaceAfterConstructor: false,
                 insertSpaceAfterKeywordsInControlFlowStatements: true,
                 insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
                 insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
@@ -478,7 +487,7 @@ namespace FourSlash {
                 endPos = endMarker.position;
             }
 
-            errors.forEach(function(error: ts.Diagnostic) {
+            errors.forEach(function (error: ts.Diagnostic) {
                 if (predicate(error.start, error.start + error.length, startPos, endPos)) {
                     exists = true;
                 }
@@ -495,7 +504,7 @@ namespace FourSlash {
                 Harness.IO.log("Unexpected error(s) found.  Error list is:");
             }
 
-            errors.forEach(function(error: ts.Diagnostic) {
+            errors.forEach(function (error: ts.Diagnostic) {
                 Harness.IO.log("  minChar: " + error.start +
                     ", limChar: " + (error.start + error.length) +
                     ", message: " + ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine()) + "\n");
@@ -1532,7 +1541,8 @@ namespace FourSlash {
             let runningOffset = 0;
             edits = edits.sort((a, b) => a.span.start - b.span.start);
             // Get a snapshot of the content of the file so we can make sure any formatting edits didn't destroy non-whitespace characters
-            const oldContent = this.getFileContent(this.activeFile.fileName);
+            const oldContent = this.getFileContent(fileName);
+
             for (const edit of edits) {
                 this.languageServiceAdapterHost.editScript(fileName, edit.span.start + runningOffset, ts.textSpanEnd(edit.span) + runningOffset, edit.newText);
                 this.updateMarkersForEdit(fileName, edit.span.start + runningOffset, ts.textSpanEnd(edit.span) + runningOffset, edit.newText);
@@ -1969,54 +1979,93 @@ namespace FourSlash {
             });
         }
 
-        private getCodeFixes(errorCode?: number) {
-            const fileName = this.activeFile.fileName;
-            const diagnostics = this.getDiagnostics(fileName);
-
-            if (diagnostics.length === 0) {
-                this.raiseError("Errors expected.");
-            }
-
-            if (diagnostics.length > 1 && errorCode === undefined) {
-                this.raiseError("When there's more than one error, you must specify the errror to fix.");
-            }
-
-            const diagnostic = !errorCode ? diagnostics[0] : ts.find(diagnostics, d => d.code == errorCode);
-
-            return this.languageService.getCodeFixesAtPosition(fileName, diagnostic.start, diagnostic.start + diagnostic.length, [diagnostic.code]);
-        }
-
-        public verifyCodeFixAtPosition(expectedText: string, errorCode?: number) {
+        /**
+         * Compares expected text to the text that would be in the sole range
+         * (ie: [|...|]) in the file after applying the codefix sole codefix
+         * in the source file.
+         * 
+         * Because codefixes are only applied on the working file, it is unsafe
+         * to apply this more than once (consider a refactoring across files).
+         */
+        public verifyRangeAfterCodeFix(expectedText: string, errorCode?: number) {
             const ranges = this.getRanges();
-            if (ranges.length == 0) {
-                this.raiseError("At least one range should be specified in the testfile.");
+            if (ranges.length !== 1) {
+                this.raiseError("Exactly one range should be specified in the testfile.");
             }
 
-            const actual = this.getCodeFixes(errorCode);
+            const fileName = this.activeFile.fileName;
 
-            if (!actual || actual.length == 0) {
-                this.raiseError("No codefixes returned.");
-            }
+            this.applyCodeFixActions(fileName, this.getCodeFixActions(fileName, errorCode));
 
-            if (actual.length > 1) {
-                this.raiseError("More than 1 codefix returned.");
-            }
-
-            this.applyEdits(actual[0].changes[0].fileName, actual[0].changes[0].textChanges, /*isFormattingEdit*/ false);
             const actualText = this.rangeText(ranges[0]);
 
             if (this.removeWhitespace(actualText) !== this.removeWhitespace(expectedText)) {
-                this.raiseError(`Actual text doesn't match expected text. Actual: '${actualText}' Expected: '${expectedText}'`);
+                this.raiseError(`Actual text doesn't match expected text. Actual:\n'${actualText}'\nExpected:\n'${expectedText}'`);
             }
         }
 
+        /**
+         * Applies fixes for the errors in fileName and compares the results to
+         * expectedContents after all fixes have been applied.
+
+         * Note: applying one codefix may generate another (eg: remove duplicate implements
+         * may generate an extends -> interface conversion fix).
+         * @param expectedContents The contents of the file after the fixes are applied.
+         * @param fileName The file to check. If not supplied, the current open file is used.
+         */
+        public verifyFileAfterCodeFix(expectedContents: string, fileName?: string) {
+            fileName = fileName ? fileName : this.activeFile.fileName;
+
+            this.applyCodeFixActions(fileName, this.getCodeFixActions(fileName));
+
+            const actualContents: string = this.getFileContent(fileName);
+            if (this.removeWhitespace(actualContents) !== this.removeWhitespace(expectedContents)) {
+                this.raiseError(`Actual text doesn't match expected text. Actual:\n${actualContents}\n\nExpected:\n${expectedContents}`);
+            }
+        }
+
+        /**
+         * Rerieves a codefix satisfying the parameters, or undefined if no such codefix is found.
+         * @param fileName Path to file where error should be retrieved from.
+         */
+        private getCodeFixActions(fileName: string, errorCode?: number): ts.CodeAction[] {
+            const diagnostics: ts.Diagnostic[] = this.getDiagnostics(fileName);
+
+            let actions: ts.CodeAction[] = undefined;
+            for (const diagnostic of diagnostics) {
+
+                if (errorCode && errorCode !== diagnostic.code) {
+                    continue;
+                }
+
+                const newActions = this.languageService.getCodeFixesAtPosition(fileName, diagnostic.start, diagnostic.length, [diagnostic.code]);
+                if (newActions && newActions.length) {
+                    actions = actions ? actions.concat(newActions) : newActions;
+                }
+            }
+            return actions;
+        }
+
+        private applyCodeFixActions(fileName: string, actions: ts.CodeAction[]): void {
+            if (!(actions && actions.length === 1)) {
+                this.raiseError(`Should find exactly one codefix, but ${actions ? actions.length : "none"} found.`);
+            }
+
+            const fileChanges = ts.find(actions[0].changes, change => change.fileName === fileName);
+            if (!fileChanges) {
+                this.raiseError("The CodeFix found doesn't provide any changes in this file.");
+            }
+
+            this.applyEdits(fileChanges.fileName, fileChanges.textChanges, /*isFormattingEdit*/ false);
+        }
+
         public verifyImportFixAtPosition(expectedTextArray: string[], errorCode?: number) {
             const ranges = this.getRanges();
             if (ranges.length == 0) {
                 this.raiseError("At least one range should be specified in the testfile.");
             }
 
-            const codeFixes = this.getCodeFixes(errorCode);
+            const codeFixes = this.getCodeFixActions(this.activeFile.fileName, errorCode);
 
             if (!codeFixes || codeFixes.length == 0) {
                 this.raiseError("No codefixes returned.");
@@ -2314,15 +2363,15 @@ namespace FourSlash {
             }
         }
 
-        public verifyCodeFixAvailable(negative: boolean, errorCode?: number) {
-            const fixes = this.getCodeFixes(errorCode);
+        public verifyCodeFixAvailable(negative: boolean) {
+            const codeFix = this.getCodeFixActions(this.activeFile.fileName);
 
-            if (negative && fixes && fixes.length > 0) {
-                this.raiseError(`verifyCodeFixAvailable failed - expected no fixes, actual: ${fixes.length}`);
+            if (negative && codeFix) {
+                this.raiseError(`verifyCodeFixAvailable failed - expected no fixes but found one.`);
             }
 
-            if (!negative && (fixes === undefined || fixes.length === 0)) {
-                this.raiseError(`verifyCodeFixAvailable failed - expected code fixes, actual: 0`);
+            if (!(negative || codeFix)) {
+                this.raiseError(`verifyCodeFixAvailable failed - expected code fixes but none found.`);
             }
         }
 
@@ -3094,8 +3143,8 @@ namespace FourSlashInterface {
             this.state.verifyBraceCompletionAtPosition(this.negative, openingBrace);
         }
 
-        public codeFixAvailable(errorCode?: number) {
-            this.state.verifyCodeFixAvailable(this.negative, errorCode);
+        public codeFixAvailable() {
+            this.state.verifyCodeFixAvailable(this.negative);
         }
     }
 
@@ -3280,8 +3329,8 @@ namespace FourSlashInterface {
             this.DocCommentTemplate(/*expectedText*/ undefined, /*expectedOffset*/ undefined, /*empty*/ true);
         }
 
-        public codeFixAtPosition(expectedText: string, errorCode?: number): void {
-            this.state.verifyCodeFixAtPosition(expectedText, errorCode);
+        public rangeAfterCodeFix(expectedText: string, errorCode?: number): void {
+            this.state.verifyRangeAfterCodeFix(expectedText, errorCode);
         }
 
         public importFixAtPosition(expectedTextArray: string[], errorCode?: number): void {
@@ -3523,11 +3572,8 @@ namespace FourSlashInterface {
             this.state.formatOnType(this.state.getMarkerByName(posMarker).position, key);
         }
 
-        public setOption(name: string, value: number): void;
-        public setOption(name: string, value: string): void;
-        public setOption(name: string, value: boolean): void;
-        public setOption(name: string, value: any): void {
-            (<any>this.state.formatCodeSettings)[name] = value;
+        public setOption(name: keyof ts.FormatCodeSettings, value: number | string | boolean): void {
+            this.state.formatCodeSettings[name] = value;
         }
     }
 

src/harness/harness.ts

@@ -85,7 +85,7 @@ namespace Utils {
                 eval(fileContents);
                 break;
             case ExecutionEnvironment.Node:
-                let vm = require("vm");
+                const vm = require("vm");
                 if (nodeContext) {
                     vm.runInNewContext(fileContents, nodeContext, fileName);
                 }
@@ -175,9 +175,9 @@ namespace Utils {
                     assert.isFalse(array.end > node.end, "array.end > node.end");
                     assert.isFalse(array.pos < currentPos, "array.pos < currentPos");
 
-                    for (let i = 0, n = array.length; i < n; i++) {
-                        assert.isFalse(array[i].pos < currentPos, "array[i].pos < currentPos");
-                        currentPos = array[i].end;
+                    for (const item of array) {
+                        assert.isFalse(item.pos < currentPos, "array[i].pos < currentPos");
+                        currentPos = item.end;
                     }
 
                     currentPos = array.end;
@@ -344,7 +344,7 @@ namespace Utils {
 
         assert.equal(array1.length, array2.length, "array1.length !== array2.length");
 
-        for (let i = 0, n = array1.length; i < n; i++) {
+        for (let i = 0; i < array1.length; i++) {
             const d1 = array1[i];
             const d2 = array2[i];
 
@@ -400,7 +400,7 @@ namespace Utils {
         assert.equal(array1.end, array2.end, "array1.end !== array2.end");
         assert.equal(array1.length, array2.length, "array1.length !== array2.length");
 
-        for (let i = 0, n = array1.length; i < n; i++) {
+        for (let i = 0; i < array1.length; i++) {
             assertStructuralEquals(array1[i], array2[i]);
         }
     }

src/harness/tsconfig.json

@@ -74,7 +74,18 @@
         "../services/formatting/rulesProvider.ts",
         "../services/formatting/smartIndenter.ts",
         "../services/formatting/tokenRange.ts",
-        "harness.ts",
+        "../services/codeFixProvider.ts",
+        "../services/codefixes/fixes.ts",
+        "../services/codefixes/fixExtendsInterfaceBecomesImplements.ts",
+        "../services/codefixes/fixClassIncorrectlyImplementsInterface.ts",
+        "../services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts",
+        "../services/codefixes/fixClassSuperMustPrecedeThisAccess.ts",
+        "../services/codefixes/fixConstructorForDerivedNeedSuperCall.ts",
+        "../services/codefixes/helpers.ts",
+        "../services/codefixes/importFixes.ts",
+        "../services/codefixes/unusedIdentifierFixes.ts",
+        "../services/harness.ts",
+        
         "sourceMapRecorder.ts",
         "harnessLanguageService.ts",
         "fourslash.ts",

src/harness/unittests/compileOnSave.ts

@@ -467,6 +467,36 @@ namespace ts.projectSystem {
     });
 
     describe("EmitFile test", () => {
+        it("should respect line endings", () => {
+            test("\n");
+            test("\r\n");
+
+            function test(newLine: string) {
+                const lines = ["var x = 1;", "var y = 2;"];
+                const path = "/a/app";
+                const f = {
+                    path: path + ".ts",
+                    content: lines.join(newLine)
+                };
+                const host = createServerHost([f], { newLine });
+                const session = createSession(host);
+                session.executeCommand(<server.protocol.OpenRequest>{
+                    seq: 1,
+                    type: "request",
+                    command: "open",
+                    arguments: { file: f.path }
+                });
+                session.executeCommand(<server.protocol.CompileOnSaveEmitFileRequest>{
+                    seq: 2,
+                    type: "request",
+                    command: "compileOnSaveEmitFile",
+                    arguments: { file: f.path }
+                });
+                const emitOutput = host.readFile(path + ".js");
+                assert.equal(emitOutput, f.content + newLine, "content of emit output should be identical with the input + newline");
+            }
+        })
+
         it("should emit specified file", () => {
             const file1 = {
                 path: "/a/b/f1.ts",
@@ -480,7 +510,7 @@ namespace ts.projectSystem {
                 path: "/a/b/tsconfig.json",
                 content: `{}`
             };
-            const host = createServerHost([file1, file2, configFile, libFile]);
+            const host = createServerHost([file1, file2, configFile, libFile], { newLine: "\r\n" });
             const typingsInstaller = createTestTypingsInstaller(host);
             const session = new server.Session(host, nullCancellationToken, /*useSingleInferredProject*/ false, typingsInstaller, Utils.byteLength, process.hrtime, nullLogger, /*canUseEvents*/ false);
 

src/harness/unittests/incrementalParser.ts

@@ -28,7 +28,7 @@ namespace ts {
         const diagnostics2 = file2.parseDiagnostics;
 
         assert.equal(diagnostics1.length, diagnostics2.length, "diagnostics1.length !== diagnostics2.length");
-        for (let i = 0, n = diagnostics1.length; i < n; i++) {
+        for (let i = 0; i < diagnostics1.length; i++) {
             const d1 = diagnostics1[i];
             const d2 = diagnostics2[i];
 

src/harness/unittests/services/colorization.ts

@@ -13,8 +13,7 @@ describe("Colorization", function () {
 
     function getEntryAtPosition(result: ts.ClassificationResult, position: number) {
         let entryPosition = 0;
-        for (let i = 0, n = result.entries.length; i < n; i++) {
-            const entry = result.entries[i];
+        for (const entry of result.entries) {
             if (entryPosition === position) {
                 return entry;
             }
@@ -43,9 +42,7 @@ describe("Colorization", function () {
     function testLexicalClassification(text: string, initialEndOfLineState: ts.EndOfLineState, ...expectedEntries: ClassificationEntry[]): void {
         const result = classifier.getClassificationsForLine(text, initialEndOfLineState, /*syntacticClassifierAbsent*/ false);
 
-        for (let i = 0, n = expectedEntries.length; i < n; i++) {
-            const expectedEntry = expectedEntries[i];
-
+        for (const expectedEntry of expectedEntries) {
             if (expectedEntry.classification === undefined) {
                 assert.equal(result.finalLexState, expectedEntry.value, "final endOfLineState does not match expected.");
             }
@@ -352,9 +349,9 @@ describe("Colorization", function () {
             // Adjusts 'pos' by accounting for the length of each portion of the string,
             // but only return the last given string
             function track(...vals: string[]): string {
-                for (let i = 0, n = vals.length; i < n; i++) {
+                for (const val of vals) {
                     pos += lastLength;
-                    lastLength = vals[i].length;
+                    lastLength = val.length;
                 }
                 return ts.lastOrUndefined(vals);
             }

src/harness/unittests/services/patternMatcher.ts

@@ -502,7 +502,7 @@ describe("PatternMatcher", function () {
     function assertArrayEquals<T>(array1: T[], array2: T[]) {
         assert.equal(array1.length, array2.length);
 
-        for (let i = 0, n = array1.length; i < n; i++) {
+        for (let i = 0; i < array1.length; i++) {
             assert.equal(array1[i], array2[i]);
         }
     }

src/harness/unittests/textStorage.ts

@@ -0,0 +1,70 @@
+/// <reference path="../harness.ts" />
+/// <reference path="../../server/scriptVersionCache.ts"/>
+/// <reference path="./tsserverProjectSystem.ts" />
+
+namespace ts.textStorage {
+    describe("Text storage", () => {
+        const f = {
+            path: "/a/app.ts",
+            content: `
+                let x = 1;
+                let y = 2;
+                function bar(a: number) {
+                    return a + 1;
+                }`
+        };
+
+        it("text based storage should be have exactly the same as script version cache", () => {
+
+            const host = ts.projectSystem.createServerHost([f]);
+
+            const ts1 = new server.TextStorage(host, server.asNormalizedPath(f.path));
+            const ts2 = new server.TextStorage(host, server.asNormalizedPath(f.path));
+
+            ts1.useScriptVersionCache();
+            ts2.useText();
+
+            const lineMap = computeLineStarts(f.content);
+
+            for (let line = 0; line < lineMap.length; line++) {
+                const start = lineMap[line];
+                const end = line === lineMap.length - 1 ? f.path.length : lineMap[line + 1];
+
+                for (let offset = 0; offset < end - start; offset++) {
+                    const pos1 = ts1.lineOffsetToPosition(line + 1, offset + 1);
+                    const pos2 = ts2.lineOffsetToPosition(line + 1, offset + 1);
+                    assert.isTrue(pos1 === pos2, `lineOffsetToPosition ${line + 1}-${offset + 1}: expected ${pos1} to equal ${pos2}`);
+                }
+
+                const {start: start1, length: length1 } = ts1.lineToTextSpan(line);
+                const {start: start2, length: length2 } = ts2.lineToTextSpan(line);
+                assert.isTrue(start1 === start2, `lineToTextSpan ${line}::start:: expected ${start1} to equal ${start2}`);
+                assert.isTrue(length1 === length2, `lineToTextSpan ${line}::length:: expected ${length1} to equal ${length2}`);
+            }
+
+            for (let pos = 0; pos < f.content.length; pos++) {
+                const { line: line1, offset: offset1 } = ts1.positionToLineOffset(pos);
+                const { line: line2, offset: offset2 } = ts2.positionToLineOffset(pos);
+                assert.isTrue(line1 === line2, `positionToLineOffset ${pos}::line:: expected ${line1} to equal ${line2}`);
+                assert.isTrue(offset1 === offset2, `positionToLineOffset ${pos}::offset:: expected ${offset1} to equal ${offset2}`);
+            }
+        });
+
+        it("should switch to script version cache if necessary", () => {
+            const host = ts.projectSystem.createServerHost([f]);
+            const ts1 = new server.TextStorage(host, server.asNormalizedPath(f.path));
+
+            ts1.getSnapshot();
+            assert.isTrue(!ts1.hasScriptVersionCache(), "should not have script version cache - 1");
+
+            ts1.edit(0, 5, "   ");
+            assert.isTrue(ts1.hasScriptVersionCache(), "have script version cache - 1");
+
+            ts1.useText();
+            assert.isTrue(!ts1.hasScriptVersionCache(), "should not have script version cache - 2");
+
+            ts1.getLineInfo(0);
+            assert.isTrue(ts1.hasScriptVersionCache(), "have script version cache - 2");
+        })
+    });
+}

src/harness/unittests/tsserverProjectSystem.ts

@@ -140,8 +140,8 @@ namespace ts.projectSystem {
     export interface TestServerHostCreationParameters {
         useCaseSensitiveFileNames?: boolean;
         executingFilePath?: string;
-        libFile?: FileOrFolder;
         currentDirectory?: string;
+        newLine?: string;
     }
 
     export function createServerHost(fileOrFolderList: FileOrFolder[], params?: TestServerHostCreationParameters): TestServerHost {
@@ -152,7 +152,8 @@ namespace ts.projectSystem {
             params.useCaseSensitiveFileNames !== undefined ? params.useCaseSensitiveFileNames : false,
             params.executingFilePath || getExecutingFilePathFromLibFile(),
             params.currentDirectory || "/",
-            fileOrFolderList);
+            fileOrFolderList,
+            params.newLine);
         return host;
     }
 
@@ -330,7 +331,6 @@ namespace ts.projectSystem {
 
     export class TestServerHost implements server.ServerHost {
         args: string[] = [];
-        newLine: "\n";
 
         private fs: ts.FileMap<FSEntry>;
         private getCanonicalFileName: (s: string) => string;
@@ -343,7 +343,7 @@ namespace ts.projectSystem {
 
         private filesOrFolders: FileOrFolder[];
 
-        constructor(public useCaseSensitiveFileNames: boolean, private executingFilePath: string, private currentDirectory: string, fileOrFolderList: FileOrFolder[]) {
+        constructor(public useCaseSensitiveFileNames: boolean, private executingFilePath: string, private currentDirectory: string, fileOrFolderList: FileOrFolder[], public readonly newLine = "\n") {
             this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
             this.toPath = s => toPath(s, currentDirectory, this.getCanonicalFileName);
 
@@ -1145,6 +1145,69 @@ namespace ts.projectSystem {
             checkNumberOfProjects(projectService, {});
         });
 
+        it("reload regular file after closing", () => {
+            const f1 = {
+                path: "/a/b/app.ts",
+                content: "x."
+            };
+            const f2 = {
+                path: "/a/b/lib.ts",
+                content: "let x: number;"
+            };
+
+            const host = createServerHost([f1, f2, libFile]);
+            const service = createProjectService(host);
+            service.openExternalProject({ projectFileName: "/a/b/project", rootFiles: toExternalFiles([f1.path, f2.path]), options: {} })
+
+            service.openClientFile(f1.path);
+            service.openClientFile(f2.path, "let x: string");
+
+            service.checkNumberOfProjects({ externalProjects: 1 });
+            checkProjectActualFiles(service.externalProjects[0], [f1.path, f2.path, libFile.path]);
+
+            const completions1 = service.externalProjects[0].getLanguageService().getCompletionsAtPosition(f1.path, 2);
+            // should contain completions for string
+            assert.isTrue(completions1.entries.some(e => e.name === "charAt"), "should contain 'charAt'");
+            assert.isFalse(completions1.entries.some(e => e.name === "toExponential"), "should not contain 'toExponential'");
+
+            service.closeClientFile(f2.path);
+            const completions2 = service.externalProjects[0].getLanguageService().getCompletionsAtPosition(f1.path, 2);
+            // should contain completions for string
+            assert.isFalse(completions2.entries.some(e => e.name === "charAt"), "should not contain 'charAt'");
+            assert.isTrue(completions2.entries.some(e => e.name === "toExponential"), "should contain 'toExponential'");
+        });
+
+        it("clear mixed content file after closing", () => {
+            const f1 = {
+                path: "/a/b/app.ts",
+                content: " "
+            };
+            const f2 = {
+                path: "/a/b/lib.html",
+                content: "<html/>"
+            };
+
+            const host = createServerHost([f1, f2, libFile]);
+            const service = createProjectService(host);
+            service.openExternalProject({ projectFileName: "/a/b/project", rootFiles: [{ fileName: f1.path }, { fileName: f2.path, hasMixedContent: true }], options: {} })
+
+            service.openClientFile(f1.path);
+            service.openClientFile(f2.path, "let somelongname: string");
+
+            service.checkNumberOfProjects({ externalProjects: 1 });
+            checkProjectActualFiles(service.externalProjects[0], [f1.path, f2.path, libFile.path]);
+
+            const completions1 = service.externalProjects[0].getLanguageService().getCompletionsAtPosition(f1.path, 0);
+            assert.isTrue(completions1.entries.some(e => e.name === "somelongname"), "should contain 'somelongname'");
+
+            service.closeClientFile(f2.path);
+            const completions2 = service.externalProjects[0].getLanguageService().getCompletionsAtPosition(f1.path, 0);
+            assert.isFalse(completions2.entries.some(e => e.name === "somelongname"), "should not contain 'somelongname'");
+            const sf2 = service.externalProjects[0].getLanguageService().getProgram().getSourceFile(f2.path);
+            assert.equal(sf2.text, "");
+        });
+
+
         it("external project with included config file opened after configured project", () => {
             const file1 = {
                 path: "/a/b/f1.ts",
@@ -1176,6 +1239,7 @@ namespace ts.projectSystem {
             projectService.closeExternalProject(externalProjectName);
             checkNumberOfProjects(projectService, { configuredProjects: 0 });
         });
+
         it("external project with included config file opened after configured project and then closed", () => {
             const file1 = {
                 path: "/a/b/f1.ts",
@@ -1529,6 +1593,67 @@ namespace ts.projectSystem {
             checkProjectActualFiles(projectService.inferredProjects[1], [file2.path]);
         });
 
+        it("tsconfig script block support", () => {
+            const file1 = {
+                path: "/a/b/f1.ts",
+                content: ` `
+            };
+            const file2 = {
+                path: "/a/b/f2.html",
+                content: `var hello = "hello";`
+            };
+            const config = {
+                path: "/a/b/tsconfig.json",
+                content: JSON.stringify({ compilerOptions: { allowJs: true } })
+            };
+            const host = createServerHost([file1, file2, config]);
+            const session = createSession(host);
+            openFilesForSession([file1], session);
+            const projectService = session.getProjectService();
+
+            // HTML file will not be included in any projects yet
+            checkNumberOfProjects(projectService, { configuredProjects: 1 });
+            checkProjectActualFiles(projectService.configuredProjects[0], [file1.path]);
+
+            // Specify .html extension as mixed content
+            const extraFileExtensions = [{ extension: ".html", scriptKind: ScriptKind.JS, isMixedContent: true }];
+            const configureHostRequest = makeSessionRequest<protocol.ConfigureRequestArguments>(CommandNames.Configure, { extraFileExtensions });
+            session.executeCommand(configureHostRequest).response;
+
+             // HTML file still not included in the project as it is closed
+            checkNumberOfProjects(projectService, { configuredProjects: 1 });
+            checkProjectActualFiles(projectService.configuredProjects[0], [file1.path]);
+
+            // Open HTML file
+            projectService.applyChangesInOpenFiles(
+                /*openFiles*/[{ fileName: file2.path, hasMixedContent: true, scriptKind: ScriptKind.JS, content: `var hello = "hello";` }],
+                /*changedFiles*/undefined,
+                /*closedFiles*/undefined);
+
+            // Now HTML file is included in the project
+            checkNumberOfProjects(projectService, { configuredProjects: 1 });
+            checkProjectActualFiles(projectService.configuredProjects[0], [file1.path, file2.path]);
+
+            // Check identifiers defined in HTML content are available in .ts file
+            const project = projectService.configuredProjects[0];
+            let completions = project.getLanguageService().getCompletionsAtPosition(file1.path, 1);
+            assert(completions && completions.entries[0].name === "hello", `expected entry hello to be in completion list`);
+
+            // Close HTML file
+            projectService.applyChangesInOpenFiles(
+                /*openFiles*/undefined,
+                /*changedFiles*/undefined,
+                /*closedFiles*/[file2.path]);
+
+            // HTML file is still included in project
+            checkNumberOfProjects(projectService, { configuredProjects: 1 });
+            checkProjectActualFiles(projectService.configuredProjects[0], [file1.path, file2.path]);
+
+            // Check identifiers defined in HTML content are not available in .ts file
+            completions = project.getLanguageService().getCompletionsAtPosition(file1.path, 5);
+            assert(completions && completions.entries[0].name !== "hello", `unexpected hello entry in completion list`);
+        });
+
         it("project structure update is deferred if files are not added\removed", () => {
             const file1 = {
                 path: "/a/b/f1.ts",
@@ -1574,7 +1699,7 @@ namespace ts.projectSystem {
             const project = projectService.externalProjects[0];
 
             const scriptInfo = project.getScriptInfo(file1.path);
-            const snap = scriptInfo.snap();
+            const snap = scriptInfo.getSnapshot();
             const actualText = snap.getText(0, snap.getLength());
             assert.equal(actualText, "", `expected content to be empty string, got "${actualText}"`);
 
@@ -1587,7 +1712,7 @@ namespace ts.projectSystem {
             projectService.closeClientFile(file1.path);
 
             const scriptInfo2 = project.getScriptInfo(file1.path);
-            const snap2 = scriptInfo2.snap();
+            const snap2 = scriptInfo2.getSnapshot();
             const actualText2 = snap2.getText(0, snap.getLength());
             assert.equal(actualText2, "", `expected content to be empty string, got "${actualText2}"`);
         });
@@ -1674,6 +1799,83 @@ namespace ts.projectSystem {
             checkNumberOfProjects(projectService, { configuredProjects: 0 });
         });
 
+        it("language service disabled state is updated in external projects", () => {
+            const f1 = {
+                path: "/a/app.js",
+                content: "var x = 1"
+            };
+            const f2 = {
+                path: "/a/largefile.js",
+                content: ""
+            };
+            const host = createServerHost([f1, f2]);
+            const originalGetFileSize = host.getFileSize;
+            host.getFileSize = (filePath: string) =>
+                filePath === f2.path ? server.maxProgramSizeForNonTsFiles + 1 : originalGetFileSize.call(host, filePath);
+
+            const service = createProjectService(host);
+            const projectFileName = "/a/proj.csproj";
+
+            service.openExternalProject({
+                projectFileName,
+                rootFiles: toExternalFiles([f1.path, f2.path]),
+                options: {}
+            });
+            service.checkNumberOfProjects({ externalProjects: 1 });
+            assert.isFalse(service.externalProjects[0].languageServiceEnabled, "language service should be disabled - 1");
+
+            service.openExternalProject({
+                projectFileName,
+                rootFiles: toExternalFiles([f1.path]),
+                options: {}
+            });
+            service.checkNumberOfProjects({ externalProjects: 1 });
+            assert.isTrue(service.externalProjects[0].languageServiceEnabled, "language service should be enabled");
+
+            service.openExternalProject({
+                projectFileName,
+                rootFiles: toExternalFiles([f1.path, f2.path]),
+                options: {}
+            });
+            service.checkNumberOfProjects({ externalProjects: 1 });
+            assert.isFalse(service.externalProjects[0].languageServiceEnabled, "language service should be disabled - 2");
+        });
+
+        it("files are properly detached when language service is disabled", () => {
+            const f1 = {
+                path: "/a/app.js",
+                content: "var x = 1"
+            };
+            const f2 = {
+                path: "/a/largefile.js",
+                content: ""
+            };
+            const f3 = {
+                path: "/a/lib.js",
+                content: "var x = 1"
+            };
+            const config = {
+                path: "/a/tsconfig.json",
+                content: JSON.stringify({ compilerOptions: { allowJs: true } })
+            };
+            const host = createServerHost([f1, f2, f3, config]);
+            const originalGetFileSize = host.getFileSize;
+            host.getFileSize = (filePath: string) =>
+                filePath === f2.path ? server.maxProgramSizeForNonTsFiles + 1 : originalGetFileSize.call(host, filePath);
+
+            const projectService = createProjectService(host);
+            projectService.openClientFile(f1.path);
+            projectService.checkNumberOfProjects({ configuredProjects: 1 });
+
+            projectService.closeClientFile(f1.path);
+            projectService.checkNumberOfProjects({});
+
+            for (const f of [f2, f3]) {
+                const scriptInfo = projectService.getScriptInfoForNormalizedPath(server.toNormalizedPath(f.path));
+                assert.equal(scriptInfo.containingProjects.length, 0, `expect 0 containing projects for '${f.path}'`)
+            }
+        });
+
         it("language service disabled events are triggered", () => {
             const f1 = {
                 path: "/a/app.js",
@@ -1773,6 +1975,31 @@ namespace ts.projectSystem {
             const edits = project.getLanguageService().getFormattingEditsForDocument(f1.path, options);
             assert.deepEqual(edits, [{ span: createTextSpan(/*start*/ 7, /*length*/ 3), newText: " " }]);
         });
+
+        it("snapshot from different caches are incompatible", () => {
+            const f1 = {
+                path: "/a/b/app.ts",
+                content: "let x = 1;"
+            };
+            const host = createServerHost([f1]);
+            const projectFileName = "/a/b/proj.csproj";
+            const projectService = createProjectService(host);
+            projectService.openExternalProject({
+                projectFileName,
+                rootFiles: [toExternalFile(f1.path)],
+                options: {}
+            })
+            projectService.openClientFile(f1.path, "let x = 1;\nlet y = 2;");
+
+            projectService.checkNumberOfProjects({ externalProjects: 1 });
+            projectService.externalProjects[0].getLanguageService(/*ensureSynchronized*/false).getNavigationBarItems(f1.path);
+            projectService.closeClientFile(f1.path);
+
+            projectService.openClientFile(f1.path);
+            projectService.checkNumberOfProjects({ externalProjects: 1 });
+            const navbar = projectService.externalProjects[0].getLanguageService(/*ensureSynchronized*/false).getNavigationBarItems(f1.path);
+            assert.equal(navbar[0].spans[0].length, f1.content.length);
+        });
     });
 
     describe("Proper errors", () => {
@@ -1842,58 +2069,17 @@ namespace ts.projectSystem {
             assert.deepEqual(resolutionTrace, [
                 "======== Resolving module 'lib' from '/a/b/app.js'. ========",
                 "Module resolution kind is not specified, using 'NodeJs'.",
-                "Loading module 'lib' from 'node_modules' folder.",
-                "File '/a/b/node_modules/lib.ts' does not exist.",
-                "File '/a/b/node_modules/lib.tsx' does not exist.",
-                "File '/a/b/node_modules/lib.d.ts' does not exist.",
-                "File '/a/b/node_modules/lib/package.json' does not exist.",
-                "File '/a/b/node_modules/lib/index.ts' does not exist.",
-                "File '/a/b/node_modules/lib/index.tsx' does not exist.",
-                "File '/a/b/node_modules/lib/index.d.ts' does not exist.",
-                "File '/a/b/node_modules/@types/lib.d.ts' does not exist.",
-                "File '/a/b/node_modules/@types/lib/package.json' does not exist.",
-                "File '/a/b/node_modules/@types/lib/index.d.ts' does not exist.",
-                "File '/a/node_modules/lib.ts' does not exist.",
-                "File '/a/node_modules/lib.tsx' does not exist.",
-                "File '/a/node_modules/lib.d.ts' does not exist.",
-                "File '/a/node_modules/lib/package.json' does not exist.",
-                "File '/a/node_modules/lib/index.ts' does not exist.",
-                "File '/a/node_modules/lib/index.tsx' does not exist.",
-                "File '/a/node_modules/lib/index.d.ts' does not exist.",
-                "File '/a/node_modules/@types/lib.d.ts' does not exist.",
-                "File '/a/node_modules/@types/lib/package.json' does not exist.",
-                "File '/a/node_modules/@types/lib/index.d.ts' does not exist.",
-                "File '/node_modules/lib.ts' does not exist.",
-                "File '/node_modules/lib.tsx' does not exist.",
-                "File '/node_modules/lib.d.ts' does not exist.",
-                "File '/node_modules/lib/package.json' does not exist.",
-                "File '/node_modules/lib/index.ts' does not exist.",
-                "File '/node_modules/lib/index.tsx' does not exist.",
-                "File '/node_modules/lib/index.d.ts' does not exist.",
-                "File '/node_modules/@types/lib.d.ts' does not exist.",
-                "File '/node_modules/@types/lib/package.json' does not exist.",
-                "File '/node_modules/@types/lib/index.d.ts' does not exist.",
-                "Loading module 'lib' from 'node_modules' folder.",
-                "File '/a/b/node_modules/lib.js' does not exist.",
-                "File '/a/b/node_modules/lib.jsx' does not exist.",
-                "File '/a/b/node_modules/lib/package.json' does not exist.",
-                "File '/a/b/node_modules/lib/index.js' does not exist.",
-                "File '/a/b/node_modules/lib/index.jsx' does not exist.",
-                "File '/a/node_modules/lib.js' does not exist.",
-                "File '/a/node_modules/lib.jsx' does not exist.",
-                "File '/a/node_modules/lib/package.json' does not exist.",
-                "File '/a/node_modules/lib/index.js' does not exist.",
-                "File '/a/node_modules/lib/index.jsx' does not exist.",
-                "File '/node_modules/lib.js' does not exist.",
-                "File '/node_modules/lib.jsx' does not exist.",
-                "File '/node_modules/lib/package.json' does not exist.",
-                "File '/node_modules/lib/index.js' does not exist.",
-                "File '/node_modules/lib/index.jsx' does not exist.",
+                "Loading module 'lib' from 'node_modules' folder, target file type 'TypeScript'.",
+                "Directory '/a/b/node_modules' does not exist, skipping all lookups in it.",
+                "Directory '/a/node_modules' does not exist, skipping all lookups in it.",
+                "Directory '/node_modules' does not exist, skipping all lookups in it.",
+                "Loading module 'lib' from 'node_modules' folder, target file type 'JavaScript'.",
+                "Directory '/a/b/node_modules' does not exist, skipping all lookups in it.",
+                "Directory '/a/node_modules' does not exist, skipping all lookups in it.",
+                "Directory '/node_modules' does not exist, skipping all lookups in it.",
                 "======== Module name 'lib' was not resolved. ========",
                 `Auto discovery for typings is enabled in project '${proj.getProjectName()}'. Running extra resolution pass for module 'lib' using cache location '/a/cache'.`,
                 "File '/a/cache/node_modules/lib.d.ts' does not exist.",
-                "File '/a/cache/node_modules/lib/package.json' does not exist.",
-                "File '/a/cache/node_modules/lib/index.d.ts' does not exist.",
                 "File '/a/cache/node_modules/@types/lib.d.ts' does not exist.",
                 "File '/a/cache/node_modules/@types/lib/package.json' does not exist.",
                 "File '/a/cache/node_modules/@types/lib/index.d.ts' exist - use it as a name resolution result.",
@@ -2285,13 +2471,13 @@ namespace ts.projectSystem {
             p.updateGraph();
 
             const scriptInfo = p.getScriptInfo(f.path);
-            checkSnapLength(scriptInfo.snap(), f.content.length);
+            checkSnapLength(scriptInfo.getSnapshot(), f.content.length);
 
             // open project and replace its content with empty string
             projectService.openClientFile(f.path, "");
-            checkSnapLength(scriptInfo.snap(), 0);
+            checkSnapLength(scriptInfo.getSnapshot(), 0);
         });
-        function checkSnapLength(snap: server.LineIndexSnapshot, expectedLength: number) {
+        function checkSnapLength(snap: IScriptSnapshot, expectedLength: number) {
             assert.equal(snap.getLength(), expectedLength, "Incorrect snapshot size");
         }
     });
@@ -2444,7 +2630,6 @@ namespace ts.projectSystem {
             const cwd = {
                 path: "/a/c"
             };
-            debugger;
             const host = createServerHost([f1, config, node, cwd], { currentDirectory: cwd.path });
             const projectService = createProjectService(host);
             projectService.openClientFile(f1.path);
@@ -2715,7 +2900,7 @@ namespace ts.projectSystem {
 
             // verify content
             const projectServiice = session.getProjectService();
-            const snap1 = projectServiice.getScriptInfo(f1.path).snap();
+            const snap1 = projectServiice.getScriptInfo(f1.path).getSnapshot();
             assert.equal(snap1.getText(0, snap1.getLength()), tmp.content, "content should be equal to the content of temp file");
 
             // reload from original file file
@@ -2727,7 +2912,7 @@ namespace ts.projectSystem {
             });
 
             // verify content
-            const snap2 = projectServiice.getScriptInfo(f1.path).snap();
+            const snap2 = projectServiice.getScriptInfo(f1.path).getSnapshot();
             assert.equal(snap2.getText(0, snap2.getLength()), f1.content, "content should be equal to the content of original file");
 
         });

src/harness/unittests/versionCache.ts

@@ -307,7 +307,7 @@ and grew 1cm per day`;
 
         it("Start pos from line", () => {
             for (let i = 0; i < iterationCount; i++) {
-                for (let j = 0, llen = lines.length; j < llen; j++) {
+                for (let j = 0; j < lines.length; j++) {
                     const lineInfo = lineIndex.lineNumberToInfo(j + 1);
                     const lineIndexOffset = lineInfo.offset;
                     const lineMapOffset = lineMap[j];

src/lib/es5.d.ts

@@ -1171,8 +1171,9 @@ interface Array<T> {
     /**
       * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
       * @param start The zero-based location in the array from which to start removing elements.
+      * @param deleteCount The number of elements to remove.
       */
-    splice(start: number): T[];
+    splice(start: number, deleteCount?: number): T[];
     /**
       * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
       * @param start The zero-based location in the array from which to start removing elements.

src/server/builder.ts

@@ -75,17 +75,32 @@ namespace ts.server {
         getFilesAffectedBy(scriptInfo: ScriptInfo): string[];
         onProjectUpdateGraph(): void;
         emitFile(scriptInfo: ScriptInfo, writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => void): boolean;
+        clear(): void;
     }
 
     abstract class AbstractBuilder<T extends BuilderFileInfo> implements Builder {
 
-        private fileInfos = createFileMap<T>();
+        /**
+         * stores set of files from the project.
+         * NOTE: this field is created on demand and should not be accessed directly.
+         * Use 'getFileInfos' instead.
+         */
+        private fileInfos_doNotAccessDirectly: FileMap<T>;
 
         constructor(public readonly project: Project, private ctor: { new (scriptInfo: ScriptInfo, project: Project): T }) {
         }
 
+        private getFileInfos() {
+            return this.fileInfos_doNotAccessDirectly || (this.fileInfos_doNotAccessDirectly = createFileMap<T>());
+        }
+
+        public clear() {
+            // drop the existing list - it will be re-created as necessary
+            this.fileInfos_doNotAccessDirectly = undefined;
+        }
+
         protected getFileInfo(path: Path): T {
-            return this.fileInfos.get(path);
+            return this.getFileInfos().get(path);
         }
 
         protected getOrCreateFileInfo(path: Path): T {
@@ -99,19 +114,19 @@ namespace ts.server {
         }
 
         protected getFileInfoPaths(): Path[] {
-            return this.fileInfos.getKeys();
+            return this.getFileInfos().getKeys();
         }
 
         protected setFileInfo(path: Path, info: T) {
-            this.fileInfos.set(path, info);
+            this.getFileInfos().set(path, info);
         }
 
         protected removeFileInfo(path: Path) {
-            this.fileInfos.remove(path);
+            this.getFileInfos().remove(path);
         }
 
         protected forEachFileInfo(action: (fileInfo: T) => any) {
-            this.fileInfos.forEachValue((_path, value) => action(value));
+            this.getFileInfos().forEachValue((_path, value) => action(value));
         }
 
         abstract getFilesAffectedBy(scriptInfo: ScriptInfo): string[];
@@ -231,6 +246,11 @@ namespace ts.server {
 
         private projectVersionForDependencyGraph: string;
 
+        public clear() {
+            this.projectVersionForDependencyGraph = undefined;
+            super.clear();
+        }
+
         private getReferencedFileInfos(fileInfo: ModuleBuilderFileInfo): ModuleBuilderFileInfo[] {
             if (!fileInfo.isExternalModuleOrHasOnlyAmbientExternalModules()) {
                 return [];

src/server/editorServices.ts

@@ -108,6 +108,7 @@ namespace ts.server {
     export interface HostConfiguration {
         formatCodeOptions: FormatCodeSettings;
         hostInfo: string;
+        extraFileExtensions?: FileExtensionInfo[];
     }
 
     interface ConfigFileConversionResult {
@@ -125,20 +126,23 @@ namespace ts.server {
     }
 
     export interface OpenConfiguredProjectResult {
-        configFileName?: string;
+        configFileName?: NormalizedPath;
         configFileErrors?: Diagnostic[];
     }
 
     interface FilePropertyReader<T> {
         getFileName(f: T): string;
         getScriptKind(f: T): ScriptKind;
-        hasMixedContent(f: T): boolean;
+        hasMixedContent(f: T, extraFileExtensions: FileExtensionInfo[]): boolean;
     }
 
     const fileNamePropertyReader: FilePropertyReader<string> = {
         getFileName: x => x,
         getScriptKind: _ => undefined,
-        hasMixedContent: _ => false
+        hasMixedContent: (fileName, extraFileExtensions) => {
+            const mixedContentExtensions = ts.map(ts.filter(extraFileExtensions, item => item.isMixedContent), item => item.extension);
+            return forEach(mixedContentExtensions, extension => fileExtensionIs(fileName, extension))
+        }
     };
 
     const externalFilePropertyReader: FilePropertyReader<protocol.ExternalFile> = {
@@ -282,7 +286,8 @@ namespace ts.server {
 
             this.hostConfiguration = {
                 formatCodeOptions: getDefaultFormatCodeSettings(this.host),
-                hostInfo: "Unknown host"
+                hostInfo: "Unknown host",
+                extraFileExtensions: []
             };
 
             this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames, host.getCurrentDirectory());
@@ -424,7 +429,7 @@ namespace ts.server {
                 this.handleDeletedFile(info);
             }
             else {
-                if (info && (!info.isOpen)) {
+                if (info && (!info.isScriptOpen())) {
                     // file has been changed which might affect the set of referenced files in projects that include 
                     // this file and set of inferred projects
                     info.reloadFromFile();
@@ -440,7 +445,7 @@ namespace ts.server {
 
             // TODO: handle isOpen = true case
 
-            if (!info.isOpen) {
+            if (!info.isScriptOpen()) {
                 this.filenameToScriptInfo.remove(info.path);
                 this.lastDeletedFile = info;
 
@@ -486,7 +491,7 @@ namespace ts.server {
             // If a change was made inside "folder/file", node will trigger the callback twice:
             // one with the fileName being "folder/file", and the other one with "folder".
             // We don't respond to the second one.
-            if (fileName && !ts.isSupportedSourceFileName(fileName, project.getCompilerOptions())) {
+            if (fileName && !ts.isSupportedSourceFileName(fileName, project.getCompilerOptions(), this.hostConfiguration.extraFileExtensions)) {
                 return;
             }
 
@@ -634,15 +639,17 @@ namespace ts.server {
             // Closing file should trigger re-reading the file content from disk. This is
             // because the user may chose to discard the buffer content before saving
             // to the disk, and the server's version of the file can be out of sync.
-            info.reloadFromFile();
+            info.close();
 
             removeItemFromSet(this.openFiles, info);
-            info.isOpen = false;
 
             // collect all projects that should be removed
             let projectsToRemove: Project[];
             for (const p of info.containingProjects) {
                 if (p.projectKind === ProjectKind.Configured) {
+                    if (info.hasMixedContent) {
+                        info.registerFileUpdate();
+                    }
                     // last open file in configured project - close it
                     if ((<ConfiguredProject>p).deleteOpenRef() === 0) {
                         (projectsToRemove || (projectsToRemove = [])).push(p);
@@ -652,6 +659,13 @@ namespace ts.server {
                     // open file in inferred project
                     (projectsToRemove || (projectsToRemove = [])).push(p);
                 }
+
+                if (!p.languageServiceEnabled) {
+                    // if project language service is disabled then we create a program only for open files.
+                    // this means that project should be marked as dirty to force rebuilding of the program
+                    // on the next request
+                    p.markAsDirty();
+                }
             }
             if (projectsToRemove) {
                 for (const project of projectsToRemove) {
@@ -811,7 +825,9 @@ namespace ts.server {
                 this.host,
                 getDirectoryPath(configFilename),
                 /*existingOptions*/ {},
-                configFilename);
+                configFilename,
+                /*resolutionStack*/ [],
+                this.hostConfiguration.extraFileExtensions);
 
             if (parsedCommandLine.errors.length) {
                 errors = concatenate(errors, parsedCommandLine.errors);
@@ -915,7 +931,7 @@ namespace ts.server {
             for (const f of files) {
                 const rootFilename = propertyReader.getFileName(f);
                 const scriptKind = propertyReader.getScriptKind(f);
-                const hasMixedContent = propertyReader.hasMixedContent(f);
+                const hasMixedContent = propertyReader.hasMixedContent(f, this.hostConfiguration.extraFileExtensions);
                 if (this.host.fileExists(rootFilename)) {
                     const info = this.getOrCreateScriptInfoForNormalizedPath(toNormalizedPath(rootFilename), /*openedByClient*/ clientFileName == rootFilename, /*fileContent*/ undefined, scriptKind, hasMixedContent);
                     project.addRoot(info);
@@ -961,7 +977,7 @@ namespace ts.server {
                     rootFilesChanged = true;
                     if (!scriptInfo) {
                         const scriptKind = propertyReader.getScriptKind(f);
-                        const hasMixedContent = propertyReader.hasMixedContent(f);
+                        const hasMixedContent = propertyReader.hasMixedContent(f, this.hostConfiguration.extraFileExtensions);
                         scriptInfo = this.getOrCreateScriptInfoForNormalizedPath(normalizedPath, /*openedByClient*/ false, /*fileContent*/ undefined, scriptKind, hasMixedContent);
                     }
                 }
@@ -989,7 +1005,7 @@ namespace ts.server {
                 }
                 if (toAdd) {
                     for (const f of toAdd) {
-                        if (f.isOpen && isRootFileInInferredProject(f)) {
+                        if (f.isScriptOpen() && isRootFileInInferredProject(f)) {
                             // if file is already root in some inferred project 
                             // - remove the file from that project and delete the project if necessary
                             const inferredProject = f.containingProjects[0];
@@ -1043,9 +1059,7 @@ namespace ts.server {
                 project.stopWatchingDirectory();
             }
             else {
-                if (!project.languageServiceEnabled) {
-                    project.enableLanguageService();
-                }
+                project.enableLanguageService();
                 this.watchConfigDirectoryForProject(project, projectOptions);
                 this.updateNonInferredProject(project, projectOptions.files, fileNamePropertyReader, projectOptions.compilerOptions, projectOptions.typeAcquisition, projectOptions.compileOnSave, configFileErrors);
             }
@@ -1089,32 +1103,34 @@ namespace ts.server {
         getOrCreateScriptInfoForNormalizedPath(fileName: NormalizedPath, openedByClient: boolean, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean) {
             let info = this.getScriptInfoForNormalizedPath(fileName);
             if (!info) {
-                let content: string;
-                if (this.host.fileExists(fileName)) {
-                    // by default pick whatever content was supplied as the argument
-                    // if argument was not given - then for mixed content files assume that its content is empty string
-                    content = fileContent || (hasMixedContent ? "" : this.host.readFile(fileName));
-                }
-                if (!content) {
-                    if (openedByClient) {
-                        content = "";
-                    }
-                }
-                if (content !== undefined) {
-                    info = new ScriptInfo(this.host, fileName, content, scriptKind, openedByClient, hasMixedContent);
-                    // do not watch files with mixed content - server doesn't know how to interpret it
+                if (openedByClient || this.host.fileExists(fileName)) {
+                    info = new ScriptInfo(this.host, fileName, scriptKind, hasMixedContent);
+
                     this.filenameToScriptInfo.set(info.path, info);
-                    if (!info.isOpen && !hasMixedContent) {
-                        info.setWatcher(this.host.watchFile(fileName, _ => this.onSourceFileChanged(fileName)));
+
+                    if (openedByClient) {
+                        if (fileContent === undefined) {
+                            // if file is opened by client and its content is not specified - use file text
+                            fileContent = this.host.readFile(fileName) || "";
+                        }
+                    }
+                    else {
+                        // do not watch files with mixed content - server doesn't know how to interpret it
+                        if (!hasMixedContent) {
+                            info.setWatcher(this.host.watchFile(fileName, _ => this.onSourceFileChanged(fileName)));
+                        }
                     }
                 }
             }
             if (info) {
-                if (fileContent !== undefined) {
-                    info.reload(fileContent);
+                if (openedByClient && !info.isScriptOpen()) {
+                    info.open(fileContent);
+                    if (hasMixedContent) {
+                        info.registerFileUpdate();
+                    }
                 }
-                if (openedByClient) {
-                    info.isOpen = true;
+                else if (fileContent !== undefined) {
+                    info.reload(fileContent);
                 }
             }
             return info;
@@ -1146,6 +1162,10 @@ namespace ts.server {
                     mergeMaps(this.hostConfiguration.formatCodeOptions, convertFormatOptions(args.formatOptions));
                     this.logger.info("Format host information updated");
                 }
+                if (args.extraFileExtensions) {
+                    this.hostConfiguration.extraFileExtensions = args.extraFileExtensions;
+                    this.logger.info("Host file extension mappings updated");
+                }
             }
         }
 
@@ -1211,9 +1231,22 @@ namespace ts.server {
         }
 
         openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean): OpenConfiguredProjectResult {
-            const { configFileName = undefined, configFileErrors = undefined }: OpenConfiguredProjectResult = this.findContainingExternalProject(fileName)
-                ? {}
-                : this.openOrUpdateConfiguredProjectForFile(fileName);
+            let configFileName: NormalizedPath;
+            let configFileErrors: Diagnostic[];
+
+            let project: ConfiguredProject | ExternalProject = this.findContainingExternalProject(fileName);
+            if (!project) {
+                ({ configFileName, configFileErrors } = this.openOrUpdateConfiguredProjectForFile(fileName));
+                if (configFileName) {
+                    project = this.findConfiguredProjectByProjectName(configFileName);
+                }
+            }
+            if (project && !project.languageServiceEnabled) {
+                // if project language service is disabled then we create a program only for open files.
+                // this means that project should be marked as dirty to force rebuilding of the program
+                // on the next request
+                project.markAsDirty();
+            }
 
             // at this point if file is the part of some configured/external project then this project should be created
             const info = this.getOrCreateScriptInfoForNormalizedPath(fileName, /*openedByClient*/ true, fileContent, scriptKind, hasMixedContent);
@@ -1230,7 +1263,6 @@ namespace ts.server {
             const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(uncheckedFileName));
             if (info) {
                 this.closeOpenFile(info);
-                info.isOpen = false;
             }
             this.printProjects();
         }
@@ -1255,7 +1287,7 @@ namespace ts.server {
             if (openFiles) {
                 for (const file of openFiles) {
                     const scriptInfo = this.getScriptInfo(file.fileName);
-                    Debug.assert(!scriptInfo || !scriptInfo.isOpen);
+                    Debug.assert(!scriptInfo || !scriptInfo.isScriptOpen());
                     const normalizedPath = scriptInfo ? scriptInfo.fileName : toNormalizedPath(file.fileName);
                     this.openClientFileWithNormalizedPath(normalizedPath, file.content, tryConvertScriptKindName(file.scriptKind), file.hasMixedContent);
                 }
@@ -1378,8 +1410,15 @@ namespace ts.server {
             let exisingConfigFiles: string[];
             if (externalProject) {
                 if (!tsConfigFiles) {
+                    const compilerOptions = convertCompilerOptions(proj.options);
+                    if (this.exceededTotalSizeLimitForNonTsFiles(compilerOptions, proj.rootFiles, externalFilePropertyReader)) {
+                        externalProject.disableLanguageService();
+                    }
+                    else {
+                        externalProject.enableLanguageService();
+                    }
                     // external project already exists and not config files were added - update the project and return;
-                    this.updateNonInferredProject(externalProject, proj.rootFiles, externalFilePropertyReader, convertCompilerOptions(proj.options), proj.typeAcquisition, proj.options.compileOnSave, /*configFileErrors*/ undefined);
+                    this.updateNonInferredProject(externalProject, proj.rootFiles, externalFilePropertyReader, compilerOptions, proj.typeAcquisition, proj.options.compileOnSave, /*configFileErrors*/ undefined);
                     return;
                 }
                 // some config files were added to external project (that previously were not there)

src/server/lsHost.ts

@@ -135,6 +135,10 @@ namespace ts.server {
             }
         }
 
+        getNewLine() {
+            return this.host.newLine;
+        }
+
         getProjectVersion() {
             return this.project.getProjectVersion();
         }
@@ -169,7 +173,7 @@ namespace ts.server {
         getScriptSnapshot(filename: string): ts.IScriptSnapshot {
             const scriptInfo = this.project.getScriptInfoLSHost(filename);
             if (scriptInfo) {
-                return scriptInfo.snap();
+                return scriptInfo.getSnapshot();
             }
         }
 

src/server/project.ts

@@ -1,4 +1,4 @@
-/// <reference path="..\services\services.ts" />
+/// <reference path="..\services\services.ts" />
 /// <reference path="utilities.ts"/>
 /// <reference path="scriptInfo.ts"/>
 /// <reference path="lsHost.ts"/>
@@ -90,87 +90,6 @@ namespace ts.server {
         }
     }
 
-    const emptyResult: any[] = [];
-    const getEmptyResult = () => emptyResult;
-    const getUndefined = () => <any>undefined;
-    const emptyEncodedSemanticClassifications = { spans: emptyResult, endOfLineState: EndOfLineState.None };
-
-    export function createNoSemanticFeaturesWrapper(realLanguageService: LanguageService): LanguageService {
-        return {
-            cleanupSemanticCache: noop,
-            getSyntacticDiagnostics: (fileName) =>
-                fileName ? realLanguageService.getSyntacticDiagnostics(fileName) : emptyResult,
-            getSemanticDiagnostics: getEmptyResult,
-            getCompilerOptionsDiagnostics: () =>
-                realLanguageService.getCompilerOptionsDiagnostics(),
-            getSyntacticClassifications: (fileName, span) =>
-                realLanguageService.getSyntacticClassifications(fileName, span),
-            getEncodedSyntacticClassifications: (fileName, span) =>
-                realLanguageService.getEncodedSyntacticClassifications(fileName, span),
-            getSemanticClassifications: getEmptyResult,
-            getEncodedSemanticClassifications: () =>
-                emptyEncodedSemanticClassifications,
-            getCompletionsAtPosition: getUndefined,
-            findReferences: getEmptyResult,
-            getCompletionEntryDetails: getUndefined,
-            getQuickInfoAtPosition: getUndefined,
-            findRenameLocations: getEmptyResult,
-            getNameOrDottedNameSpan: (fileName, startPos, endPos) =>
-                realLanguageService.getNameOrDottedNameSpan(fileName, startPos, endPos),
-            getBreakpointStatementAtPosition: (fileName, position) =>
-                realLanguageService.getBreakpointStatementAtPosition(fileName, position),
-            getBraceMatchingAtPosition: (fileName, position) =>
-                realLanguageService.getBraceMatchingAtPosition(fileName, position),
-            getSignatureHelpItems: getUndefined,
-            getDefinitionAtPosition: getEmptyResult,
-            getRenameInfo: () => ({
-                canRename: false,
-                localizedErrorMessage: getLocaleSpecificMessage(Diagnostics.Language_service_is_disabled),
-                displayName: undefined,
-                fullDisplayName: undefined,
-                kind: undefined,
-                kindModifiers: undefined,
-                triggerSpan: undefined
-            }),
-            getTypeDefinitionAtPosition: getUndefined,
-            getReferencesAtPosition: getEmptyResult,
-            getDocumentHighlights: getEmptyResult,
-            getOccurrencesAtPosition: getEmptyResult,
-            getNavigateToItems: getEmptyResult,
-            getNavigationBarItems: fileName =>
-                realLanguageService.getNavigationBarItems(fileName),
-            getNavigationTree: fileName =>
-                realLanguageService.getNavigationTree(fileName),
-            getOutliningSpans: fileName =>
-                realLanguageService.getOutliningSpans(fileName),
-            getTodoComments: getEmptyResult,
-            getIndentationAtPosition: (fileName, position, options) =>
-                realLanguageService.getIndentationAtPosition(fileName, position, options),
-            getFormattingEditsForRange: (fileName, start, end, options) =>
-                realLanguageService.getFormattingEditsForRange(fileName, start, end, options),
-            getFormattingEditsForDocument: (fileName, options) =>
-                realLanguageService.getFormattingEditsForDocument(fileName, options),
-            getFormattingEditsAfterKeystroke: (fileName, position, key, options) =>
-                realLanguageService.getFormattingEditsAfterKeystroke(fileName, position, key, options),
-            getDocCommentTemplateAtPosition: (fileName, position) =>
-                realLanguageService.getDocCommentTemplateAtPosition(fileName, position),
-            isValidBraceCompletionAtPosition: (fileName, position, openingBrace) =>
-                realLanguageService.isValidBraceCompletionAtPosition(fileName, position, openingBrace),
-            getEmitOutput: getUndefined,
-            getProgram: () =>
-                realLanguageService.getProgram(),
-            getNonBoundSourceFile: fileName =>
-                realLanguageService.getNonBoundSourceFile(fileName),
-            dispose: () =>
-                realLanguageService.dispose(),
-            getCompletionEntrySymbol: getUndefined,
-            getImplementationAtPosition: getEmptyResult,
-            getSourceFile: fileName =>
-                realLanguageService.getSourceFile(fileName),
-            getCodeFixesAtPosition: getEmptyResult
-        };
-    }
-
     export abstract class Project {
         private rootFiles: ScriptInfo[] = [];
         private rootFilesMap: FileMap<ScriptInfo> = createFileMap<ScriptInfo>();
@@ -181,12 +100,14 @@ namespace ts.server {
         private lastCachedUnresolvedImportsList: SortedReadonlyArray<string>;
 
         private readonly languageService: LanguageService;
-        // wrapper over the real language service that will suppress all semantic operations
-        private readonly noSemanticFeaturesLanguageService: LanguageService;
 
         public languageServiceEnabled = true;
 
         builder: Builder;
+        /**
+         * Set of files names that were updated since the last call to getChangesSinceVersion.
+         */
+        private updatedFileNames: Map<string>;
         /**
          * Set of files that was returned from the last call to getChangesSinceVersion.
          */
@@ -254,7 +175,6 @@ namespace ts.server {
             this.lsHost.setCompilationSettings(this.compilerOptions);
 
             this.languageService = ts.createLanguageService(this.lsHost, this.documentRegistry);
-            this.noSemanticFeaturesLanguageService = createNoSemanticFeaturesWrapper(this.languageService);
 
             if (!languageServiceEnabled) {
                 this.disableLanguageService();
@@ -278,9 +198,7 @@ namespace ts.server {
             if (ensureSynchronized) {
                 this.updateGraph();
             }
-            return this.languageServiceEnabled
-                ? this.languageService
-                : this.noSemanticFeaturesLanguageService;
+            return this.languageService;
         }
 
         getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[] {
@@ -339,8 +257,9 @@ namespace ts.server {
                     info.detachFromProject(this);
                 }
             }
-            else {
-                // release all root files
+            if (!this.program || !this.languageServiceEnabled) {
+                // release all root files either if there is no program or language service is disabled.
+                // in the latter case set of root files can be larger than the set of files in program.
                 for (const root of this.rootFiles) {
                     root.detachFromProject(this);
                 }
@@ -369,7 +288,10 @@ namespace ts.server {
             const result: string[] = [];
             if (this.rootFiles) {
                 for (const f of this.rootFiles) {
-                    result.push(f.fileName);
+                    if (this.languageServiceEnabled || f.isScriptOpen()) {
+                        // if language service is disabled - process only files that are open
+                        result.push(f.fileName);
+                    }
                 }
                 if (this.typingFiles) {
                     for (const f of this.typingFiles) {
@@ -385,6 +307,10 @@ namespace ts.server {
         }
 
         getScriptInfos() {
+            if (!this.languageServiceEnabled) {
+                // if language service is not enabled - return just root files
+                return this.rootFiles;
+            }
             return map(this.program.getSourceFiles(), sourceFile => {
                 const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.path);
                 if (!scriptInfo) {
@@ -448,7 +374,7 @@ namespace ts.server {
 
         containsFile(filename: NormalizedPath, requireOpen?: boolean) {
             const info = this.projectService.getScriptInfoForNormalizedPath(filename);
-            if (info && (info.isOpen || !requireOpen)) {
+            if (info && (info.isScriptOpen() || !requireOpen)) {
                 return this.containsScriptInfo(info);
             }
         }
@@ -480,6 +406,10 @@ namespace ts.server {
             this.markAsDirty();
         }
 
+        registerFileUpdate(fileName: string) {
+            (this.updatedFileNames || (this.updatedFileNames = createMap<string>()))[fileName] = fileName;
+        }
+
         markAsDirty() {
             this.projectStateVersion++;
         }
@@ -521,10 +451,6 @@ namespace ts.server {
          * @returns: true if set of files in the project stays the same and false - otherwise.
          */
         updateGraph(): boolean {
-            if (!this.languageServiceEnabled) {
-                return true;
-            }
-
             this.lsHost.startRecordingFilesWithChangedResolutions();
 
             let hasChanges = this.updateGraphWorker();
@@ -556,6 +482,16 @@ namespace ts.server {
             if (this.setTypings(cachedTypings)) {
                 hasChanges = this.updateGraphWorker() || hasChanges;
             }
+
+            // update builder only if language service is enabled
+            // otherwise tell it to drop its internal state
+            if (this.languageServiceEnabled) {
+                this.builder.onProjectUpdateGraph();
+            }
+            else {
+                this.builder.clear();
+            }
+
             if (hasChanges) {
                 this.projectStructureVersion++;
             }
@@ -594,7 +530,6 @@ namespace ts.server {
                     }
                 }
             }
-            this.builder.onProjectUpdateGraph();
             return hasChanges;
         }
 
@@ -665,12 +600,15 @@ namespace ts.server {
                 projectName: this.getProjectName(),
                 version: this.projectStructureVersion,
                 isInferred: this.projectKind === ProjectKind.Inferred,
-                options: this.getCompilerOptions()
+                options: this.getCompilerOptions(),
+                languageServiceDisabled: !this.languageServiceEnabled
             };
+            const updatedFileNames = this.updatedFileNames;
+            this.updatedFileNames = undefined;
             // check if requested version is the same that we have reported last time
             if (this.lastReportedFileNames && lastKnownVersion === this.lastReportedVersion) {
-                // if current structure version is the same - return info witout any changes
-                if (this.projectStructureVersion == this.lastReportedVersion) {
+                // if current structure version is the same - return info without any changes
+                if (this.projectStructureVersion == this.lastReportedVersion && !updatedFileNames) {
                     return { info, projectErrors: this.projectErrors };
                 }
                 // compute and return the difference
@@ -679,6 +617,7 @@ namespace ts.server {
 
                 const added: string[] = [];
                 const removed: string[] = [];
+                const updated: string[] = getOwnKeys(updatedFileNames);
                 for (const id in currentFiles) {
                     if (!hasProperty(lastReportedFileNames, id)) {
                         added.push(id);
@@ -691,7 +630,7 @@ namespace ts.server {
                 }
                 this.lastReportedFileNames = currentFiles;
                 this.lastReportedVersion = this.projectStructureVersion;
-                return { info, changes: { added, removed }, projectErrors: this.projectErrors };
+                return { info, changes: { added, removed, updated }, projectErrors: this.projectErrors };
             }
             else {
                 // unknown version - return everything

src/server/protocol.ts

@@ -1,4 +1,4 @@
-/**
+/**
   * Declaration module describing the TypeScript Server protocol
   */
 namespace ts.server.protocol {
@@ -904,6 +904,11 @@ namespace ts.server.protocol {
          * Current set of compiler options for project
          */
         options: ts.CompilerOptions;
+
+        /**
+         * true if project language service is disabled
+         */
+        languageServiceDisabled: boolean;
     }
 
     /**
@@ -918,6 +923,10 @@ namespace ts.server.protocol {
          * List of removed files
          */
         removed: string[];
+        /**
+         * List of updated files
+         */
+        updated: string[];
     }
 
     /**
@@ -990,6 +999,11 @@ namespace ts.server.protocol {
          * The format options to use during formatting and other code editing features.
          */
         formatOptions?: FormatCodeSettings;
+
+        /**
+         * The host's additional supported file extensions
+         */
+        extraFileExtensions?: FileExtensionInfo[];
     }
 
     /**
@@ -2180,12 +2194,14 @@ namespace ts.server.protocol {
         insertSpaceAfterCommaDelimiter?: boolean;
         insertSpaceAfterSemicolonInForStatements?: boolean;
         insertSpaceBeforeAndAfterBinaryOperators?: boolean;
+        insertSpaceAfterConstructor?: boolean;
         insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
         insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
+        insertSpaceBeforeFunctionParenthesis?: boolean;
         placeOpenBraceOnNewLineForFunctions?: boolean;
         placeOpenBraceOnNewLineForControlBlocks?: boolean;
     }

src/server/scriptInfo.ts

@@ -2,6 +2,161 @@
 
 namespace ts.server {
 
+    /* @internal */
+    export class TextStorage {
+        private svc: ScriptVersionCache | undefined;
+        private svcVersion = 0;
+
+        private text: string;
+        private lineMap: number[];
+        private textVersion = 0;
+
+        constructor(private readonly host: ServerHost, private readonly fileName: NormalizedPath) {
+        }
+
+        public getVersion() {
+            return this.svc
+                ? `SVC-${this.svcVersion}-${this.svc.getSnapshot().version}`
+                : `Text-${this.textVersion}`;
+        }
+
+        public hasScriptVersionCache() {
+            return this.svc !== undefined;
+        }
+
+        public useScriptVersionCache(newText?: string) {
+            this.switchToScriptVersionCache(newText);
+        }
+
+        public useText(newText?: string) {
+            this.svc = undefined;
+            this.setText(newText);
+        }
+
+        public edit(start: number, end: number, newText: string) {
+            this.switchToScriptVersionCache().edit(start, end - start, newText);
+        }
+
+        public reload(text: string) {
+            if (this.svc) {
+                this.svc.reload(text);
+            }
+            else {
+                this.setText(text);
+            }
+        }
+
+        public reloadFromFile(tempFileName?: string) {
+            if (this.svc || (tempFileName !== this.fileName)) {
+                this.reload(this.getFileText(tempFileName))
+            }
+            else {
+                this.setText(undefined);
+            }
+        }
+
+        public getSnapshot(): IScriptSnapshot {
+            return this.svc
+                ? this.svc.getSnapshot()
+                : ScriptSnapshot.fromString(this.getOrLoadText());
+        }
+
+        public getLineInfo(line: number) {
+            return this.switchToScriptVersionCache().getSnapshot().index.lineNumberToInfo(line);
+        }
+        /**
+         *  @param line 0 based index
+         */
+        lineToTextSpan(line: number) {
+            if (!this.svc) {
+                const lineMap = this.getLineMap();
+                const start = lineMap[line]; // -1 since line is 1-based
+                const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
+                return ts.createTextSpanFromBounds(start, end);
+            }
+            const index = this.svc.getSnapshot().index;
+            const lineInfo = index.lineNumberToInfo(line + 1);
+            let len: number;
+            if (lineInfo.leaf) {
+                len = lineInfo.leaf.text.length;
+            }
+            else {
+                const nextLineInfo = index.lineNumberToInfo(line + 2);
+                len = nextLineInfo.offset - lineInfo.offset;
+            }
+            return ts.createTextSpan(lineInfo.offset, len);
+        }
+
+        /**
+         * @param line 1 based index
+         * @param offset 1 based index
+         */
+        lineOffsetToPosition(line: number, offset: number): number {
+            if (!this.svc) {
+                return computePositionOfLineAndCharacter(this.getLineMap(), line - 1, offset - 1);
+            }
+            const index = this.svc.getSnapshot().index;
+
+            const lineInfo = index.lineNumberToInfo(line);
+            // TODO: assert this offset is actually on the line
+            return (lineInfo.offset + offset - 1);
+        }
+
+        /**
+         * @param line 1-based index
+         * @param offset 1-based index
+         */
+        positionToLineOffset(position: number): ILineInfo {
+            if (!this.svc) {
+                const { line, character } = computeLineAndCharacterOfPosition(this.getLineMap(), position);
+                return { line: line + 1, offset: character + 1 };
+            }
+            const index = this.svc.getSnapshot().index;
+            const lineOffset = index.charOffsetToLineNumberAndPos(position);
+            return { line: lineOffset.line, offset: lineOffset.offset + 1 };
+        }
+
+        private getFileText(tempFileName?: string) {
+            return this.host.readFile(tempFileName || this.fileName) || "";
+        }
+
+        private ensureNoScriptVersionCache() {
+            Debug.assert(!this.svc, "ScriptVersionCache should not be set");
+        }
+
+        private switchToScriptVersionCache(newText?: string): ScriptVersionCache {
+            if (!this.svc) {
+                this.svc = ScriptVersionCache.fromString(this.host, newText !== undefined ? newText : this.getOrLoadText());
+                this.svcVersion++;
+                this.text = undefined;
+            }
+            return this.svc;
+        }
+
+        private getOrLoadText() {
+            this.ensureNoScriptVersionCache();
+            if (this.text === undefined) {
+                this.setText(this.getFileText());
+            }
+            return this.text;
+        }
+
+        private getLineMap() {
+            this.ensureNoScriptVersionCache();
+            return this.lineMap || (this.lineMap = computeLineStarts(this.getOrLoadText()));
+        }
+
+        private setText(newText: string) {
+            this.ensureNoScriptVersionCache();
+            if (newText === undefined || this.text !== newText) {
+                this.text = newText;
+                this.lineMap = undefined;
+                this.textVersion++;
+            }
+        }
+    }
+
+
     export class ScriptInfo {
         /**
          * All projects that include this file
@@ -11,24 +166,46 @@ namespace ts.server {
         readonly path: Path;
 
         private fileWatcher: FileWatcher;
-        private svc: ScriptVersionCache;
+        private textStorage: TextStorage;
+
+        private isOpen: boolean;
 
-        // TODO: allow to update hasMixedContent from the outside
         constructor(
             private readonly host: ServerHost,
             readonly fileName: NormalizedPath,
-            content: string,
             readonly scriptKind: ScriptKind,
-            public isOpen = false,
             public hasMixedContent = false) {
 
             this.path = toPath(fileName, host.getCurrentDirectory(), createGetCanonicalFileName(host.useCaseSensitiveFileNames));
-            this.svc = ScriptVersionCache.fromString(host, content);
+            this.textStorage = new TextStorage(host, fileName);
+            if (hasMixedContent) {
+                this.textStorage.reload("");
+            }
             this.scriptKind = scriptKind
                 ? scriptKind
                 : getScriptKindFromFileName(fileName);
         }
 
+        public isScriptOpen() {
+            return this.isOpen;
+        }
+
+        public open(newText: string) {
+            this.isOpen = true;
+            this.textStorage.useScriptVersionCache(newText);
+            this.markContainingProjectsAsDirty();
+        }
+
+        public close() {
+            this.isOpen = false;
+            this.textStorage.useText(this.hasMixedContent ? "" : undefined);
+            this.markContainingProjectsAsDirty();
+        }
+
+        public getSnapshot() {
+            return this.textStorage.getSnapshot();
+        }
+
         getFormatCodeSettings() {
             return this.formatCodeSettings;
         }
@@ -90,6 +267,12 @@ namespace ts.server {
             return this.containingProjects[0];
         }
 
+        registerFileUpdate(): void {
+            for (const p of this.containingProjects) {
+                p.registerFileUpdate(this.path);
+            }
+        }
+
         setFormatOptions(formatSettings: FormatCodeSettings): void {
             if (formatSettings) {
                 if (!this.formatCodeSettings) {
@@ -112,16 +295,16 @@ namespace ts.server {
         }
 
         getLatestVersion() {
-            return this.svc.latestVersion().toString();
+            return this.textStorage.getVersion();
         }
 
         reload(script: string) {
-            this.svc.reload(script);
+            this.textStorage.reload(script);
             this.markContainingProjectsAsDirty();
         }
 
         saveTo(fileName: string) {
-            const snap = this.snap();
+            const snap = this.textStorage.getSnapshot();
             this.host.writeFile(fileName, snap.getText(0, snap.getLength()));
         }
 
@@ -130,22 +313,17 @@ namespace ts.server {
                 this.reload("");
             }
             else {
-                this.svc.reloadFromFile(tempFileName || this.fileName);
+                this.textStorage.reloadFromFile(tempFileName);
                 this.markContainingProjectsAsDirty();
             }
         }
 
-        snap() {
-            return this.svc.getSnapshot();
-        }
-
         getLineInfo(line: number) {
-            const snap = this.snap();
-            return snap.index.lineNumberToInfo(line);
+            return this.textStorage.getLineInfo(line);
         }
 
         editContent(start: number, end: number, newText: string): void {
-            this.svc.edit(start, end - start, newText);
+            this.textStorage.edit(start, end, newText);
             this.markContainingProjectsAsDirty();
         }
 
@@ -159,17 +337,7 @@ namespace ts.server {
          *  @param line 1 based index
          */
         lineToTextSpan(line: number) {
-            const index = this.snap().index;
-            const lineInfo = index.lineNumberToInfo(line + 1);
-            let len: number;
-            if (lineInfo.leaf) {
-                len = lineInfo.leaf.text.length;
-            }
-            else {
-                const nextLineInfo = index.lineNumberToInfo(line + 2);
-                len = nextLineInfo.offset - lineInfo.offset;
-            }
-            return ts.createTextSpan(lineInfo.offset, len);
+            return this.textStorage.lineToTextSpan(line);
         }
 
         /**
@@ -177,11 +345,7 @@ namespace ts.server {
          * @param offset 1 based index
          */
         lineOffsetToPosition(line: number, offset: number): number {
-            const index = this.snap().index;
-
-            const lineInfo = index.lineNumberToInfo(line);
-            // TODO: assert this offset is actually on the line
-            return (lineInfo.offset + offset - 1);
+            return this.textStorage.lineOffsetToPosition(line, offset);
         }
 
         /**
@@ -189,9 +353,7 @@ namespace ts.server {
          * @param offset 1-based index
          */
         positionToLineOffset(position: number): ILineInfo {
-            const index = this.snap().index;
-            const lineOffset = index.charOffsetToLineNumberAndPos(position);
-            return { line: lineOffset.line, offset: lineOffset.offset + 1 };
+            return this.textStorage.positionToLineOffset(position);
         }
     }
 }

src/server/scriptVersionCache.ts

@@ -113,7 +113,7 @@ namespace ts.server {
                 if (len > 1) {
                     let insertedNodes = <LineCollection[]>new Array(len - 1);
                     let startNode = <LineCollection>leafNode;
-                    for (let i = 1, len = lines.length; i < len; i++) {
+                    for (let i = 1; i < lines.length; i++) {
                         insertedNodes[i - 1] = new LineLeaf(lines[i]);
                     }
                     let pathIndex = this.startPath.length - 2;
@@ -341,8 +341,7 @@ namespace ts.server {
             let snap = this.versions[this.currentVersionToIndex()];
             if (this.changes.length > 0) {
                 let snapIndex = snap.index;
-                for (let i = 0, len = this.changes.length; i < len; i++) {
-                    const change = this.changes[i];
+                for (const change of this.changes) {
                     snapIndex = snapIndex.edit(change.pos, change.deleteLen, change.insertedText);
                 }
                 snap = new LineIndexSnapshot(this.currentVersion + 1, this);
@@ -366,8 +365,7 @@ namespace ts.server {
                     const textChangeRanges: ts.TextChangeRange[] = [];
                     for (let i = oldVersion + 1; i <= newVersion; i++) {
                         const snap = this.versions[this.versionToIndex(i)];
-                        for (let j = 0, len = snap.changesSincePreviousVersion.length; j < len; j++) {
-                            const textChange = snap.changesSincePreviousVersion[j];
+                        for (const textChange of snap.changesSincePreviousVersion) {
                             textChangeRanges[textChangeRanges.length] = textChange.getTextChangeRange();
                         }
                     }
@@ -398,7 +396,7 @@ namespace ts.server {
         index: LineIndex;
         changesSincePreviousVersion: TextChange[] = [];
 
-        constructor(public version: number, public cache: ScriptVersionCache) {
+        constructor(readonly version: number, readonly cache: ScriptVersionCache) {
         }
 
         getText(rangeStart: number, rangeEnd: number) {
@@ -438,8 +436,9 @@ namespace ts.server {
             }
         }
         getChangeRange(oldSnapshot: ts.IScriptSnapshot): ts.TextChangeRange {
-            const oldSnap = <LineIndexSnapshot>oldSnapshot;
-            return this.getTextChangeRangeSinceVersion(oldSnap.version);
+            if (oldSnapshot instanceof LineIndexSnapshot && this.cache === oldSnapshot.cache) {
+                return this.getTextChangeRangeSinceVersion(oldSnapshot.version);
+            }
         }
     }
 
@@ -470,7 +469,7 @@ namespace ts.server {
         load(lines: string[]) {
             if (lines.length > 0) {
                 const leaves: LineLeaf[] = [];
-                for (let i = 0, len = lines.length; i < len; i++) {
+                for (let i = 0; i < lines.length; i++) {
                     leaves[i] = new LineLeaf(lines[i]);
                 }
                 this.root = LineIndex.buildTreeFromBottom(leaves);
@@ -642,8 +641,7 @@ namespace ts.server {
         updateCounts() {
             this.totalChars = 0;
             this.totalLines = 0;
-            for (let i = 0, len = this.children.length; i < len; i++) {
-                const child = this.children[i];
+            for (const child of this.children) {
                 this.totalChars += child.charCount();
                 this.totalLines += child.lineCount();
             }

src/server/server.ts

@@ -409,7 +409,8 @@ namespace ts.server {
     function parseLoggingEnvironmentString(logEnvStr: string): LogOptions {
         const logEnv: LogOptions = { logToFile: true };
         const args = logEnvStr.split(" ");
-        for (let i = 0, len = args.length; i < (len - 1); i += 2) {
+        const len = args.length - 1;
+        for (let i = 0; i < len; i += 2) {
             const option = args[i];
             const value = args[i + 1];
             if (option && value) {

src/server/session.ts

@@ -709,7 +709,7 @@ namespace ts.server {
                 const displayString = ts.displayPartsToString(nameInfo.displayParts);
                 const nameSpan = nameInfo.textSpan;
                 const nameColStart = scriptInfo.positionToLineOffset(nameSpan.start).offset;
-                const nameText = scriptInfo.snap().getText(nameSpan.start, ts.textSpanEnd(nameSpan));
+                const nameText = scriptInfo.getSnapshot().getText(nameSpan.start, ts.textSpanEnd(nameSpan));
                 const refs = combineProjectOutput<protocol.ReferencesResponseItem>(
                     projects,
                     (project: Project) => {
@@ -722,7 +722,7 @@ namespace ts.server {
                             const refScriptInfo = project.getScriptInfo(ref.fileName);
                             const start = refScriptInfo.positionToLineOffset(ref.textSpan.start);
                             const refLineSpan = refScriptInfo.lineToTextSpan(start.line - 1);
-                            const lineText = refScriptInfo.snap().getText(refLineSpan.start, ts.textSpanEnd(refLineSpan)).replace(/\r|\n/g, "");
+                            const lineText = refScriptInfo.getSnapshot().getText(refLineSpan.start, ts.textSpanEnd(refLineSpan)).replace(/\r|\n/g, "");
                             return {
                                 file: ref.fileName,
                                 start: start,
@@ -1026,6 +1026,9 @@ namespace ts.server {
             if (!project) {
                 Errors.ThrowNoProject();
             }
+            if (!project.languageServiceEnabled) {
+                return false;
+            }
             const scriptInfo = project.getScriptInfo(file);
             return project.builder.emitFile(scriptInfo, (path, data, writeByteOrderMark) => this.host.writeFile(path, data, writeByteOrderMark));
         }
@@ -1326,7 +1329,7 @@ namespace ts.server {
                     highPriorityFiles.push(fileNameInProject);
                 else {
                     const info = this.projectService.getScriptInfo(fileNameInProject);
-                    if (!info.isOpen) {
+                    if (!info.isScriptOpen()) {
                         if (fileNameInProject.indexOf(".d.ts") > 0)
                             veryLowPriorityFiles.push(fileNameInProject);
                         else

src/server/utilities.ts

@@ -1,4 +1,4 @@
-/// <reference path="types.d.ts" />
+/// <reference path="types.d.ts" />
 /// <reference path="shared.ts" />
 
 namespace ts.server {
@@ -78,6 +78,7 @@ namespace ts.server {
             newLineCharacter: host.newLine || "\n",
             convertTabsToSpaces: true,
             indentStyle: ts.IndentStyle.Smart,
+            insertSpaceAfterConstructor: false,
             insertSpaceAfterCommaDelimiter: true,
             insertSpaceAfterSemicolonInForStatements: true,
             insertSpaceBeforeAndAfterBinaryOperators: true,
@@ -85,8 +86,10 @@ namespace ts.server {
             insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
             insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
             insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
+            insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
             insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
             insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
+            insertSpaceBeforeFunctionParenthesis: false,
             placeOpenBraceOnNewLineForFunctions: false,
             placeOpenBraceOnNewLineForControlBlocks: false,
         };

src/services/breakpoints.ts

@@ -560,11 +560,11 @@ namespace ts.BreakpointResolver {
             function spanInOpenBraceToken(node: Node): TextSpan {
                 switch (node.parent.kind) {
                     case SyntaxKind.EnumDeclaration:
-                        let enumDeclaration = <EnumDeclaration>node.parent;
+                        const enumDeclaration = <EnumDeclaration>node.parent;
                         return spanInNodeIfStartsOnSameLine(findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile));
 
                     case SyntaxKind.ClassDeclaration:
-                        let classDeclaration = <ClassDeclaration>node.parent;
+                        const classDeclaration = <ClassDeclaration>node.parent;
                         return spanInNodeIfStartsOnSameLine(findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile));
 
                     case SyntaxKind.CaseBlock:
@@ -600,8 +600,8 @@ namespace ts.BreakpointResolver {
 
                     case SyntaxKind.CaseBlock:
                         // breakpoint in last statement of the last clause
-                        let caseBlock = <CaseBlock>node.parent;
-                        let lastClause = lastOrUndefined(caseBlock.clauses);
+                        const caseBlock = <CaseBlock>node.parent;
+                        const lastClause = lastOrUndefined(caseBlock.clauses);
                         if (lastClause) {
                             return spanInNode(lastOrUndefined(lastClause.statements));
                         }
@@ -609,7 +609,7 @@ namespace ts.BreakpointResolver {
 
                     case SyntaxKind.ObjectBindingPattern:
                         // Breakpoint in last binding element or binding pattern if it contains no elements
-                        let bindingPattern = <BindingPattern>node.parent;
+                        const bindingPattern = <BindingPattern>node.parent;
                         return spanInNode(lastOrUndefined(bindingPattern.elements) || bindingPattern);
 
                     // Default to parent node
@@ -627,7 +627,7 @@ namespace ts.BreakpointResolver {
                 switch (node.parent.kind) {
                     case SyntaxKind.ArrayBindingPattern:
                         // Breakpoint in last binding element or binding pattern if it contains no elements
-                        let bindingPattern = <BindingPattern>node.parent;
+                        const bindingPattern = <BindingPattern>node.parent;
                         return textSpan(lastOrUndefined(bindingPattern.elements) || bindingPattern);
 
                     default:

src/services/classifier.ts

@@ -71,7 +71,7 @@ namespace ts {
             const dense = classifications.spans;
             let lastEnd = 0;
 
-            for (let i = 0, n = dense.length; i < n; i += 3) {
+            for (let i = 0; i < dense.length; i += 3) {
                 const start = dense[i];
                 const length = dense[i + 1];
                 const type = <ClassificationType>dense[i + 2];
@@ -605,7 +605,7 @@ namespace ts {
         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) {
+        for (let i = 0; i < dense.length; i += 3) {
             result.push({
                 textSpan: createTextSpan(dense[i], dense[i + 1]),
                 classificationType: getClassificationTypeName(dense[i + 2])
@@ -972,9 +972,7 @@ namespace ts {
             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];
+                for (const child of element.getChildren(sourceFile)) {
                     if (!tryClassifyNode(child)) {
                         // Recurse into our child nodes.
                         processElement(child);

src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts

@@ -0,0 +1,59 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code],
+        getCodeActions: getActionForClassLikeMissingAbstractMember
+    });
+
+    registerCodeFix({
+        errorCodes: [Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code],
+        getCodeActions: getActionForClassLikeMissingAbstractMember
+    });
+
+    function getActionForClassLikeMissingAbstractMember(context: CodeFixContext): CodeAction[] | undefined {
+        const sourceFile = context.sourceFile;
+        const start = context.span.start;
+        // This is the identifier in the case of a class declaration
+        // or the class keyword token in the case of a class expression.
+        const token = getTokenAtPosition(sourceFile, start);
+        const checker = context.program.getTypeChecker();
+
+        if (isClassLike(token.parent)) {
+            const classDecl = token.parent as ClassLikeDeclaration;
+            const startPos = classDecl.members.pos;
+
+            const classType = checker.getTypeAtLocation(classDecl) as InterfaceType;
+            const instantiatedExtendsType = checker.getBaseTypes(classType)[0];
+
+            // Note that this is ultimately derived from a map indexed by symbol names,
+            // so duplicates cannot occur.
+            const extendsSymbols = checker.getPropertiesOfType(instantiatedExtendsType);
+            const abstractAndNonPrivateExtendsSymbols = extendsSymbols.filter(symbolPointsToNonPrivateAndAbstractMember);
+
+            const insertion = getMissingMembersInsertion(classDecl, abstractAndNonPrivateExtendsSymbols, checker, context.newLineCharacter);
+
+            if (insertion.length) {
+                return [{
+                    description: getLocaleSpecificMessage(Diagnostics.Implement_inherited_abstract_class),
+                    changes: [{
+                        fileName: sourceFile.fileName,
+                        textChanges: [{
+                            span: { start: startPos, length: 0 },
+                            newText: insertion
+                        }]
+                    }]
+                }];
+            }
+        }
+
+        return undefined;
+
+    }
+
+    function symbolPointsToNonPrivateAndAbstractMember(symbol: Symbol): boolean {
+        const decls = symbol.getDeclarations();
+        Debug.assert(!!(decls && decls.length > 0));
+        const flags = getModifierFlags(decls[0]);
+        return !(flags & ModifierFlags.Private) && !!(flags & ModifierFlags.Abstract);
+    }
+}

src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts

@@ -0,0 +1,75 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics.Class_0_incorrectly_implements_interface_1.code],
+        getCodeActions: getActionForClassLikeIncorrectImplementsInterface
+    });
+
+    function getActionForClassLikeIncorrectImplementsInterface(context: CodeFixContext): CodeAction[] | undefined {
+        const sourceFile = context.sourceFile;
+        const start = context.span.start;
+        const token = getTokenAtPosition(sourceFile, start);
+        const checker = context.program.getTypeChecker();
+
+        const classDecl = getContainingClass(token);
+        if (!classDecl) {
+            return undefined;
+        }
+
+        const startPos: number = classDecl.members.pos;
+        const classType = checker.getTypeAtLocation(classDecl);
+        const implementedTypeNodes = getClassImplementsHeritageClauseElements(classDecl);
+
+        const hasNumericIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.Number);
+        const hasStringIndexSignature = !!checker.getIndexTypeOfType(classType, IndexKind.String);
+
+        const result: CodeAction[] = [];
+        for (const implementedTypeNode of implementedTypeNodes) {
+            const implementedType = checker.getTypeFromTypeNode(implementedTypeNode) as InterfaceType;
+            // Note that this is ultimately derived from a map indexed by symbol names,
+            // so duplicates cannot occur.
+            const implementedTypeSymbols = checker.getPropertiesOfType(implementedType);
+            const nonPrivateMembers = implementedTypeSymbols.filter(symbol => !(getModifierFlags(symbol.valueDeclaration) & ModifierFlags.Private));
+
+            let insertion = getMissingIndexSignatureInsertion(implementedType, IndexKind.Number, classDecl, hasNumericIndexSignature);
+            insertion += getMissingIndexSignatureInsertion(implementedType, IndexKind.String, classDecl, hasStringIndexSignature);
+            insertion += getMissingMembersInsertion(classDecl, nonPrivateMembers, checker, context.newLineCharacter);
+
+            const message = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Implement_interface_0), [implementedTypeNode.getText()]);
+            if (insertion) {
+                pushAction(result, insertion, message);
+            }
+        }
+
+        return result;
+
+        function getMissingIndexSignatureInsertion(type: InterfaceType, kind: IndexKind, enclosingDeclaration: ClassLikeDeclaration, hasIndexSigOfKind: boolean) {
+            if (!hasIndexSigOfKind) {
+                const IndexInfoOfKind = checker.getIndexInfoOfType(type, kind);
+                if (IndexInfoOfKind) {
+                    const writer = getSingleLineStringWriter();
+                    checker.getSymbolDisplayBuilder().buildIndexSignatureDisplay(IndexInfoOfKind, writer, kind, enclosingDeclaration);
+                    const result = writer.string();
+                    releaseStringWriter(writer);
+
+                    return result;
+                }
+            }
+            return "";
+        }
+
+        function pushAction(result: CodeAction[], insertion: string, description: string): void {
+            const newAction: CodeAction = {
+                description: description,
+                changes: [{
+                    fileName: sourceFile.fileName,
+                    textChanges: [{
+                        span: { start: startPos, length: 0 },
+                        newText: insertion
+                    }]
+                }]
+            };
+            result.push(newAction);
+        }
+    }
+}

src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts

@@ -1,28 +1,5 @@
 /* @internal */
 namespace ts.codefix {
-    function getOpenBraceEnd(constructor: ConstructorDeclaration, sourceFile: SourceFile) {
-        // First token is the open curly, this is where we want to put the 'super' call.
-        return constructor.body.getFirstToken(sourceFile).getEnd();
-    }
-
-    registerCodeFix({
-        errorCodes: [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code],
-        getCodeActions: (context: CodeFixContext) => {
-            const sourceFile = context.sourceFile;
-            const token = getTokenAtPosition(sourceFile, context.span.start);
-
-            if (token.kind !== SyntaxKind.ConstructorKeyword) {
-                return undefined;
-            }
-
-            const newPosition = getOpenBraceEnd(<ConstructorDeclaration>token.parent, sourceFile);
-            return [{
-                description: getLocaleSpecificMessage(Diagnostics.Add_missing_super_call),
-                changes: [{ fileName: sourceFile.fileName, textChanges: [{ newText: "super();", span: { start: newPosition, length: 0 } }] }]
-            }];
-        }
-    });
-
     registerCodeFix({
         errorCodes: [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code],
         getCodeActions: (context: CodeFixContext) => {

src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts

@@ -0,0 +1,20 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+            const token = getTokenAtPosition(sourceFile, context.span.start);
+
+            if (token.kind !== SyntaxKind.ConstructorKeyword) {
+                return undefined;
+            }
+
+            const newPosition = getOpenBraceEnd(<ConstructorDeclaration>token.parent, sourceFile);
+            return [{
+                description: getLocaleSpecificMessage(Diagnostics.Add_missing_super_call),
+                changes: [{ fileName: sourceFile.fileName, textChanges: [{ newText: "super();", span: { start: newPosition, length: 0 } }] }]
+            }];
+        }
+    });
+}

src/services/codefixes/fixExtendsInterfaceBecomesImplements.ts

@@ -0,0 +1,49 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+            const start = context.span.start;
+            const token = getTokenAtPosition(sourceFile, start);
+            const classDeclNode = getContainingClass(token);
+            if (!(token.kind === SyntaxKind.Identifier && isClassLike(classDeclNode))) {
+                return undefined;
+            }
+
+            const heritageClauses = classDeclNode.heritageClauses;
+            if (!(heritageClauses && heritageClauses.length > 0)) {
+                return undefined;
+            }
+
+            const extendsToken = heritageClauses[0].getFirstToken();
+            if (!(extendsToken && extendsToken.kind === SyntaxKind.ExtendsKeyword)) {
+                return undefined;
+            }
+
+            let changeStart = extendsToken.getStart(sourceFile);
+            let changeEnd = extendsToken.getEnd();
+            const textChanges: TextChange[] = [{ newText: " implements", span: { start: changeStart, length: changeEnd - changeStart } }];
+
+            // We replace existing keywords with commas.
+            for (let i = 1; i < heritageClauses.length; i++) {
+                const keywordToken = heritageClauses[i].getFirstToken();
+                if (keywordToken) {
+                    changeStart = keywordToken.getStart(sourceFile);
+                    changeEnd = keywordToken.getEnd();
+                    textChanges.push({ newText: ",", span: { start: changeStart, length: changeEnd - changeStart } });
+                }
+            }
+
+            const result = [{
+                description: getLocaleSpecificMessage(Diagnostics.Change_extends_to_implements),
+                changes: [{
+                    fileName: sourceFile.fileName,
+                    textChanges: textChanges
+                }]
+            }];
+
+            return result;
+        }
+    });
+}

src/services/codefixes/fixes.ts

@@ -1,3 +1,9 @@
-///<reference path='superFixes.ts' />
-///<reference path='importFixes.ts' />
-///<reference path='unusedIdentifierFixes.ts' />
+/// <reference path="fixClassIncorrectlyImplementsInterface.ts" />
+/// <reference path="fixClassDoesntImplementInheritedAbstractMember.ts" />
+/// <reference path="fixClassSuperMustPrecedeThisAccess.ts" />
+/// <reference path="fixConstructorForDerivedNeedSuperCall.ts" />
+/// <reference path="fixExtendsInterfaceBecomesImplements.ts" />
+/// <reference path='unusedIdentifierFixes.ts' />
+/// <reference path='importFixes.ts' />
+/// <reference path='helpers.ts' />
+

src/services/codefixes/helpers.ts

@@ -0,0 +1,156 @@
+/* @internal */
+namespace ts.codefix {
+
+    /**
+     * Finds members of the resolved type that are missing in the class pointed to by class decl
+     * and generates source code for the missing members.
+     * @param possiblyMissingSymbols The collection of symbols to filter and then get insertions for.
+     * @returns Empty string iff there are no member insertions.
+     */
+    export function getMissingMembersInsertion(classDeclaration: ClassLikeDeclaration, possiblyMissingSymbols: Symbol[], checker: TypeChecker, newlineChar: string): string {
+        const classMembers = classDeclaration.symbol.members;
+        const missingMembers = possiblyMissingSymbols.filter(symbol => !(symbol.getName() in classMembers));
+
+        let insertion = "";
+
+        for (const symbol of missingMembers) {
+            insertion = insertion.concat(getInsertionForMemberSymbol(symbol, classDeclaration, checker, newlineChar));
+        }
+        return insertion;
+    }
+
+    /**
+     * @returns Empty string iff there we can't figure out a representation for `symbol` in `enclosingDeclaration`.
+     */
+    function getInsertionForMemberSymbol(symbol: Symbol, enclosingDeclaration: ClassLikeDeclaration, checker: TypeChecker, newlineChar: string): string {
+        // const name = symbol.getName();
+        const type = checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration);
+        const declarations = symbol.getDeclarations();
+        if (!(declarations && declarations.length)) {
+            return "";
+        }
+
+        const declaration = declarations[0] as Declaration;
+        const name = declaration.name ? declaration.name.getText() : undefined;
+        const visibility = getVisibilityPrefix(getModifierFlags(declaration));
+
+        switch (declaration.kind) {
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.PropertyDeclaration:
+                const typeString = checker.typeToString(type, enclosingDeclaration, TypeFormatFlags.None);
+                return `${visibility}${name}: ${typeString};${newlineChar}`;
+
+            case SyntaxKind.MethodSignature:
+            case SyntaxKind.MethodDeclaration:
+                // The signature for the implementation appears as an entry in `signatures` iff
+                // there is only one signature.
+                // If there are overloads and an implementation signature, it appears as an
+                // extra declaration that isn't a signature for `type`.
+                // If there is more than one overload but no implementation signature
+                // (eg: an abstract method or interface declaration), there is a 1-1
+                // correspondence of declarations and signatures.
+                const signatures = checker.getSignaturesOfType(type, SignatureKind.Call);
+                if (!(signatures && signatures.length > 0)) {
+                    return "";
+                }
+                if (declarations.length === 1) {
+                    Debug.assert(signatures.length === 1);
+                    const sigString = checker.signatureToString(signatures[0], enclosingDeclaration, TypeFormatFlags.SuppressAnyReturnType, SignatureKind.Call);
+                    return `${visibility}${name}${sigString}${getMethodBodyStub(newlineChar)}`;
+                }
+
+                let result = "";
+                for (let i = 0; i < signatures.length; i++) {
+                    const sigString = checker.signatureToString(signatures[i], enclosingDeclaration, TypeFormatFlags.SuppressAnyReturnType, SignatureKind.Call);
+                    result += `${visibility}${name}${sigString};${newlineChar}`;
+                }
+
+                // If there is a declaration with a body, it is the last declaration,
+                // and it isn't caught by `getSignaturesOfType`.
+                let bodySig: Signature | undefined = undefined;
+                if (declarations.length > signatures.length) {
+                    bodySig = checker.getSignatureFromDeclaration(declarations[declarations.length - 1] as SignatureDeclaration);
+                }
+                else {
+                    Debug.assert(declarations.length === signatures.length);
+                    bodySig = createBodySignatureWithAnyTypes(signatures, enclosingDeclaration, checker);
+                }
+                const sigString = checker.signatureToString(bodySig, enclosingDeclaration, TypeFormatFlags.SuppressAnyReturnType, SignatureKind.Call);
+                result += `${visibility}${name}${sigString}${getMethodBodyStub(newlineChar)}`;
+
+                return result;
+            default:
+                return "";
+        }
+    }
+
+    function createBodySignatureWithAnyTypes(signatures: Signature[], enclosingDeclaration: ClassLikeDeclaration, checker: TypeChecker): Signature {
+        const newSignatureDeclaration = createNode(SyntaxKind.CallSignature) as SignatureDeclaration;
+        newSignatureDeclaration.parent = enclosingDeclaration;
+        newSignatureDeclaration.name = signatures[0].getDeclaration().name;
+
+        let maxNonRestArgs = -1;
+        let maxArgsIndex = 0;
+        let minArgumentCount = signatures[0].minArgumentCount;
+        let hasRestParameter = false;
+        for (let i = 0; i < signatures.length; i++) {
+            const sig = signatures[i];
+            minArgumentCount = Math.min(sig.minArgumentCount, minArgumentCount);
+            hasRestParameter = hasRestParameter || sig.hasRestParameter;
+            const nonRestLength = sig.parameters.length - (sig.hasRestParameter ? 1 : 0);
+            if (nonRestLength > maxNonRestArgs) {
+                maxNonRestArgs = nonRestLength;
+                maxArgsIndex = i;
+            }
+        }
+        const maxArgsParameterSymbolNames = signatures[maxArgsIndex].getParameters().map(symbol => symbol.getName());
+
+        const optionalToken = createToken(SyntaxKind.QuestionToken);
+
+        newSignatureDeclaration.parameters = createNodeArray<ParameterDeclaration>();
+        for (let i = 0; i < maxNonRestArgs; i++) {
+            const newParameter = createParameterDeclarationWithoutType(i, minArgumentCount, newSignatureDeclaration);
+            newSignatureDeclaration.parameters.push(newParameter);
+        }
+
+        if (hasRestParameter) {
+            const restParameter = createParameterDeclarationWithoutType(maxNonRestArgs, minArgumentCount, newSignatureDeclaration);
+            restParameter.dotDotDotToken = createToken(SyntaxKind.DotDotDotToken);
+            newSignatureDeclaration.parameters.push(restParameter);
+        }
+
+        return checker.getSignatureFromDeclaration(newSignatureDeclaration);
+
+        function createParameterDeclarationWithoutType(index: number, minArgCount: number, enclosingSignatureDeclaration: SignatureDeclaration): ParameterDeclaration {
+            const newParameter = createNode(SyntaxKind.Parameter) as ParameterDeclaration;
+
+            newParameter.symbol = new SymbolConstructor(SymbolFlags.FunctionScopedVariable, maxArgsParameterSymbolNames[index] || "rest");
+            newParameter.symbol.valueDeclaration = newParameter;
+            newParameter.symbol.declarations = [newParameter];
+            newParameter.parent = enclosingSignatureDeclaration;
+            if (index >= minArgCount) {
+                newParameter.questionToken = optionalToken;
+            }
+
+            return newParameter;
+        }
+    }
+
+    function getMethodBodyStub(newLineChar: string) {
+        return ` {${newLineChar}throw new Error('Method not implemented.');${newLineChar}}${newLineChar}`;
+    }
+
+    function getVisibilityPrefix(flags: ModifierFlags): string {
+        if (flags & ModifierFlags.Public) {
+            return "public ";
+        }
+        else if (flags & ModifierFlags.Protected) {
+            return "protected ";
+        }
+        return "";
+    }
+
+    const SymbolConstructor = objectAllocator.getSymbolConstructor();
+}

src/services/codefixes/importFixes.ts

@@ -112,7 +112,10 @@ namespace ts.codefix {
     }
 
     registerCodeFix({
-        errorCodes: [Diagnostics.Cannot_find_name_0.code],
+        errorCodes: [
+            Diagnostics.Cannot_find_name_0.code,
+            Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code
+        ],
         getCodeActions: (context: CodeFixContext) => {
             const sourceFile = context.sourceFile;
             const checker = context.program.getTypeChecker();
@@ -127,6 +130,12 @@ namespace ts.codefix {
             const cachedImportDeclarations = createMap<(ImportDeclaration | ImportEqualsDeclaration)[]>();
             let cachedNewImportInsertPosition: number;
 
+            const currentTokenMeaning = getMeaningFromLocation(token);
+            if (context.errorCode === Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
+                const symbol = checker.getAliasedSymbol(checker.getSymbolAtLocation(token));
+                return getCodeActionForImport(symbol, /*isDefault*/ false, /*isNamespaceImport*/ true);
+            }
+
             const allPotentialModules = checker.getAmbientModules();
             for (const otherSourceFile of allSourceFiles) {
                 if (otherSourceFile !== sourceFile && isExternalOrCommonJsModule(otherSourceFile)) {
@@ -134,7 +143,6 @@ namespace ts.codefix {
                 }
             }
 
-            const currentTokenMeaning = getMeaningFromLocation(token);
             for (const moduleSymbol of allPotentialModules) {
                 context.cancellationToken.throwIfCancellationRequested();
 
@@ -203,7 +211,7 @@ namespace ts.codefix {
                 return declarations ? some(symbol.declarations, decl => !!(getMeaningFromDeclaration(decl) & meaning)) : false;
             }
 
-            function getCodeActionForImport(moduleSymbol: Symbol, isDefault?: boolean): ImportCodeAction[] {
+            function getCodeActionForImport(moduleSymbol: Symbol, isDefault?: boolean, isNamespaceImport?: boolean): ImportCodeAction[] {
                 const existingDeclarations = getImportDeclarations(moduleSymbol);
                 if (existingDeclarations.length > 0) {
                     // With an existing import statement, there are more than one actions the user can do.
@@ -213,8 +221,6 @@ namespace ts.codefix {
                     return [getCodeActionForNewImport()];
                 }
 
-
-
                 function getCodeActionsForExistingImport(declarations: (ImportDeclaration | ImportEqualsDeclaration)[]): ImportCodeAction[] {
                     const actions: ImportCodeAction[] = [];
 
@@ -262,7 +268,7 @@ namespace ts.codefix {
                         actions.push(getCodeActionForNamespaceImport(namespaceImportDeclaration));
                     }
 
-                    if (namedImportDeclaration && namedImportDeclaration.importClause &&
+                    if (!isNamespaceImport && namedImportDeclaration && namedImportDeclaration.importClause &&
                         (namedImportDeclaration.importClause.name || namedImportDeclaration.importClause.namedBindings)) {
                         /**
                          * If the existing import declaration already has a named import list, just
@@ -386,7 +392,9 @@ namespace ts.codefix {
                     const moduleSpecifierWithoutQuotes = stripQuotes(moduleSpecifier || getModuleSpecifierForNewImport());
                     const importStatementText = isDefault
                         ? `import ${name} from "${moduleSpecifierWithoutQuotes}"`
-                        : `import { ${name} } from "${moduleSpecifierWithoutQuotes}"`;
+                        : isNamespaceImport
+                            ? `import * as ${name} from "${moduleSpecifierWithoutQuotes}"`
+                            : `import { ${name} } from "${moduleSpecifierWithoutQuotes}"`;
 
                     // if this file doesn't have any import statements, insert an import statement and then insert a new line
                     // between the only import statement and user code. Otherwise just insert the statement because chances

src/services/completions.ts

@@ -244,6 +244,9 @@ namespace ts.Completions {
         }
 
         function addStringLiteralCompletionsFromType(type: Type, result: CompletionEntry[]): void {
+            if (type && type.flags & TypeFlags.TypeParameter) {
+                type = typeChecker.getApparentType(type);
+            }
             if (!type) {
                 return;
             }

src/services/formatting/formatting.ts

@@ -488,18 +488,32 @@ namespace ts.formatting {
                         // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent
                         case SyntaxKind.OpenBraceToken:
                         case SyntaxKind.CloseBraceToken:
-                        case SyntaxKind.OpenBracketToken:
-                        case SyntaxKind.CloseBracketToken:
                         case SyntaxKind.OpenParenToken:
                         case SyntaxKind.CloseParenToken:
                         case SyntaxKind.ElseKeyword:
                         case SyntaxKind.WhileKeyword:
                         case SyntaxKind.AtToken:
                             return indentation;
-                        default:
-                            // if token line equals to the line of containing node (this is a first token in the node) - use node indentation
-                            return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation;
+                        case SyntaxKind.SlashToken:
+                        case SyntaxKind.GreaterThanToken: {
+                            if (container.kind === SyntaxKind.JsxOpeningElement ||
+                                container.kind === SyntaxKind.JsxClosingElement ||
+                                container.kind === SyntaxKind.JsxSelfClosingElement
+                            ) {
+                                return indentation;
+                            }
+                            break;
+                        }
+                        case SyntaxKind.OpenBracketToken:
+                        case SyntaxKind.CloseBracketToken: {
+                            if (container.kind !== SyntaxKind.MappedType) {
+                                return indentation;
+                            }
+                            break;
+                        }
                     }
+                    // if token line equals to the line of containing node (this is a first token in the node) - use node indentation
+                    return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation;
                 },
                 getIndentation: () => indentation,
                 getDelta: child => getEffectiveDelta(delta, child),
@@ -566,7 +580,7 @@ namespace ts.formatting {
                 if (tokenInfo.token.end > node.end) {
                     break;
                 }
-                consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation);
+                consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
             }
 
             function processChildNode(
@@ -617,7 +631,7 @@ namespace ts.formatting {
                         break;
                     }
 
-                    consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation);
+                    consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, node);
                 }
 
                 if (!formattingScanner.isOnToken()) {
@@ -673,11 +687,11 @@ namespace ts.formatting {
                                 computeIndentation(tokenInfo.token, startLine, Constants.Unknown, parent, parentDynamicIndentation, parentStartLine);
 
                             listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentation.indentation, indentation.delta);
-                            consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation);
+                            consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent);
                         }
                         else {
                             // consume any tokens that precede the list as child elements of 'node' using its indentation scope
-                            consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation);
+                            consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation, parent);
                         }
                     }
                 }
@@ -697,13 +711,13 @@ namespace ts.formatting {
                         // without this check close paren will be interpreted as list end token for function expression which is wrong
                         if (tokenInfo.token.kind === listEndToken && rangeContainsRange(parent, tokenInfo.token)) {
                             // consume list end token
-                            consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation);
+                            consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent);
                         }
                     }
                 }
             }
 
-            function consumeTokenAndAdvanceScanner(currentTokenInfo: TokenInfo, parent: Node, dynamicIndentation: DynamicIndentation, container?: Node): void {
+            function consumeTokenAndAdvanceScanner(currentTokenInfo: TokenInfo, parent: Node, dynamicIndentation: DynamicIndentation, container: Node): void {
                 Debug.assert(rangeContainsRange(parent, currentTokenInfo.token));
 
                 const lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine();
@@ -950,7 +964,7 @@ namespace ts.formatting {
 
             // shift all parts on the delta size
             const delta = indentation - nonWhitespaceColumnInFirstPart.column;
-            for (let i = startIndex, len = parts.length; i < len; i++ , startLine++) {
+            for (let i = startIndex; i < parts.length; i++ , startLine++) {
                 const startLinePos = getStartPositionOfLine(startLine, sourceFile);
                 const nonWhitespaceCharacterAndColumn =
                     i === 0

src/services/formatting/rules.ts

@@ -87,6 +87,7 @@ namespace ts.formatting {
         public SpaceAfterLetConstInVariableDeclaration: Rule;
         public NoSpaceBeforeOpenParenInFuncCall: Rule;
         public SpaceAfterFunctionInFuncDecl: Rule;
+        public SpaceBeforeOpenParenInFuncDecl: Rule;
         public NoSpaceBeforeOpenParenInFuncDecl: Rule;
         public SpaceAfterVoidOperator: Rule;
 
@@ -112,6 +113,7 @@ namespace ts.formatting {
         // TypeScript-specific rules
 
         // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses
+        public SpaceAfterConstructor: Rule;
         public NoSpaceAfterConstructor: Rule;
 
         // Use of module as a function call. e.g.: import m2 = module("m2");
@@ -243,6 +245,9 @@ namespace ts.formatting {
         public NoSpaceAfterTypeAssertion: Rule;
         public SpaceAfterTypeAssertion: Rule;
 
+        // No space before non-null assertion operator
+        public NoSpaceBeforeNonNullAssertionOperator: Rule;
+
         constructor() {
             ///
             /// Common Rules
@@ -262,12 +267,12 @@ namespace ts.formatting {
             this.SpaceAfterSemicolon = new Rule(RuleDescriptor.create3(SyntaxKind.SemicolonToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
 
             // Space after }.
-            this.SpaceAfterCloseBrace = new Rule(RuleDescriptor.create3(SyntaxKind.CloseBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsAfterCodeBlockContext), RuleAction.Space));
+            this.SpaceAfterCloseBrace = new Rule(RuleDescriptor.create3(SyntaxKind.CloseBraceToken, Shared.TokenRange.FromRange(SyntaxKind.FirstToken, SyntaxKind.LastToken, [SyntaxKind.CloseParenToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsAfterCodeBlockContext), RuleAction.Space));
 
             // Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied
             this.SpaceBetweenCloseBraceAndElse = new Rule(RuleDescriptor.create1(SyntaxKind.CloseBraceToken, SyntaxKind.ElseKeyword), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
             this.SpaceBetweenCloseBraceAndWhile = new Rule(RuleDescriptor.create1(SyntaxKind.CloseBraceToken, SyntaxKind.WhileKeyword), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
-            this.NoSpaceAfterCloseBrace = new Rule(RuleDescriptor.create3(SyntaxKind.CloseBraceToken, Shared.TokenRange.FromTokens([SyntaxKind.CloseParenToken, SyntaxKind.CloseBracketToken, SyntaxKind.CommaToken, SyntaxKind.SemicolonToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
+            this.NoSpaceAfterCloseBrace = new Rule(RuleDescriptor.create3(SyntaxKind.CloseBraceToken, Shared.TokenRange.FromTokens([SyntaxKind.CloseBracketToken, SyntaxKind.CommaToken, SyntaxKind.SemicolonToken])), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
 
             // No space for dot
             this.NoSpaceBeforeDot = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.DotToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
@@ -290,10 +295,10 @@ namespace ts.formatting {
             this.SpaceBeforeOpenBraceInControl = new Rule(RuleDescriptor.create2(this.ControlOpenBraceLeftTokenRange, SyntaxKind.OpenBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsControlDeclContext, Rules.IsNotFormatOnEnter, Rules.IsSameLineTokenOrBeforeMultilineBlockContext), RuleAction.Space), RuleFlags.CanDeleteNewLines);
 
             // 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.SpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Space));
+            this.SpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Space));
+            this.NoSpaceAfterOpenBrace = new Rule(RuleDescriptor.create3(SyntaxKind.OpenBraceToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), RuleAction.Delete));
+            this.NoSpaceBeforeCloseBrace = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.CloseBraceToken), RuleOperation.create2(new RuleOperationContext(Rules.IsBraceWrappedContext), 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.
@@ -329,6 +334,7 @@ namespace ts.formatting {
             this.SpaceAfterLetConstInVariableDeclaration = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.LetKeyword, SyntaxKind.ConstKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsStartOfVariableDeclarationList), RuleAction.Space));
             this.NoSpaceBeforeOpenParenInFuncCall = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsFunctionCallOrNewContext, Rules.IsPreviousTokenNotComma), RuleAction.Delete));
             this.SpaceAfterFunctionInFuncDecl = new Rule(RuleDescriptor.create3(SyntaxKind.FunctionKeyword, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsFunctionDeclContext), RuleAction.Space));
+            this.SpaceBeforeOpenParenInFuncDecl = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsFunctionDeclContext), RuleAction.Space));
             this.NoSpaceBeforeOpenParenInFuncDecl = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsFunctionDeclContext), RuleAction.Delete));
             this.SpaceAfterVoidOperator = new Rule(RuleDescriptor.create3(SyntaxKind.VoidKeyword, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsVoidOpContext), RuleAction.Space));
 
@@ -352,13 +358,14 @@ namespace ts.formatting {
             // TypeScript-specific higher priority rules
 
             // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses
+            this.SpaceAfterConstructor = new Rule(RuleDescriptor.create1(SyntaxKind.ConstructorKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
             this.NoSpaceAfterConstructor = new Rule(RuleDescriptor.create1(SyntaxKind.ConstructorKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
 
             // Use of module as a function call. e.g.: import m2 = module("m2");
             this.NoSpaceAfterModuleImport = new Rule(RuleDescriptor.create2(Shared.TokenRange.FromTokens([SyntaxKind.ModuleKeyword, SyntaxKind.RequireKeyword]), SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
 
             // Add a space around certain TypeScript keywords
-            this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.AbstractKeyword, SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword, SyntaxKind.TypeKeyword, SyntaxKind.FromKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
+            this.SpaceAfterCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.AbstractKeyword, SyntaxKind.ClassKeyword, SyntaxKind.DeclareKeyword, SyntaxKind.DefaultKeyword, SyntaxKind.EnumKeyword, SyntaxKind.ExportKeyword, SyntaxKind.ExtendsKeyword, SyntaxKind.GetKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.ImportKeyword, SyntaxKind.InterfaceKeyword, SyntaxKind.ModuleKeyword, SyntaxKind.NamespaceKeyword, SyntaxKind.PrivateKeyword, SyntaxKind.PublicKeyword, SyntaxKind.ProtectedKeyword, SyntaxKind.ReadonlyKeyword, SyntaxKind.SetKeyword, SyntaxKind.StaticKeyword, SyntaxKind.TypeKeyword, SyntaxKind.FromKeyword, SyntaxKind.KeyOfKeyword]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
             this.SpaceBeforeCertainTypeScriptKeywords = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.ExtendsKeyword, SyntaxKind.ImplementsKeyword, SyntaxKind.FromKeyword])), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext), RuleAction.Space));
 
             // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" {
@@ -406,6 +413,9 @@ namespace ts.formatting {
             this.NoSpaceBeforeEqualInJsxAttribute = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.EqualsToken), RuleOperation.create2(new RuleOperationContext(Rules.IsJsxAttributeContext, Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
             this.NoSpaceAfterEqualInJsxAttribute = new Rule(RuleDescriptor.create3(SyntaxKind.EqualsToken, Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsJsxAttributeContext, Rules.IsNonJsxSameLineTokenContext), RuleAction.Delete));
 
+            // No space before non-null assertion operator
+            this.NoSpaceBeforeNonNullAssertionOperator = new Rule(RuleDescriptor.create2(Shared.TokenRange.Any, SyntaxKind.ExclamationToken), RuleOperation.create2(new RuleOperationContext(Rules.IsNonJsxSameLineTokenContext, Rules.IsNonNullAssertionContext), RuleAction.Delete));
+
             // These rules are higher in priority than user-configurable rules.
             this.HighPriorityCommonRules = [
                 this.IgnoreBeforeComment, this.IgnoreAfterLineComment,
@@ -437,7 +447,7 @@ namespace ts.formatting {
                 this.NoSpaceBeforeEqualInJsxAttribute, this.NoSpaceAfterEqualInJsxAttribute,
 
                 // TypeScript-specific rules
-                this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport,
+                this.NoSpaceAfterModuleImport,
                 this.SpaceAfterCertainTypeScriptKeywords, this.SpaceBeforeCertainTypeScriptKeywords,
                 this.SpaceAfterModuleName,
                 this.SpaceBeforeArrow, this.SpaceAfterArrow,
@@ -452,6 +462,7 @@ namespace ts.formatting {
                 this.SpaceBeforeAt,
                 this.NoSpaceAfterAt,
                 this.SpaceAfterDecorator,
+                this.NoSpaceBeforeNonNullAssertionOperator
             ];
 
             // These rules are lower in priority than user-configurable rules.
@@ -462,7 +473,6 @@ namespace ts.formatting {
                 this.NoSpaceBeforeOpenBracket,
                 this.NoSpaceAfterCloseBracket,
                 this.SpaceAfterSemicolon,
-                this.NoSpaceBeforeOpenParenInFuncDecl,
                 this.SpaceBetweenStatements, this.SpaceAfterTryFinally
             ];
 
@@ -575,6 +585,8 @@ namespace ts.formatting {
                     return context.currentTokenSpan.kind === SyntaxKind.EqualsToken || context.nextTokenSpan.kind === SyntaxKind.EqualsToken;
                 // "in" keyword in for (let x in []) { }
                 case SyntaxKind.ForInStatement:
+                // "in" keyword in [P in keyof T]: T[P]
+                case SyntaxKind.TypeParameter:
                     return context.currentTokenSpan.kind === SyntaxKind.InKeyword || context.nextTokenSpan.kind === SyntaxKind.InKeyword;
                 // Technically, "of" is not a binary operator, but format it the same way as "in"
                 case SyntaxKind.ForOfStatement:
@@ -612,6 +624,10 @@ namespace ts.formatting {
             return context.TokensAreOnSameLine() || Rules.IsBeforeMultilineBlockContext(context);
         }
 
+        static IsBraceWrappedContext(context: FormattingContext): boolean {
+            return context.contextNode.kind === SyntaxKind.ObjectBindingPattern || Rules.IsSingleLineBlockContext(context);
+        }
+
         // This check is done before an open brace in a control construct, a function, or a typescript block declaration
         static IsBeforeMultilineBlockContext(context: FormattingContext): boolean {
             return Rules.IsBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine());
@@ -705,11 +721,18 @@ namespace ts.formatting {
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.EnumDeclaration:
-                case SyntaxKind.Block:
                 case SyntaxKind.CatchClause:
                 case SyntaxKind.ModuleBlock:
                 case SyntaxKind.SwitchStatement:
                     return true;
+                case SyntaxKind.Block: {
+                    const blockParent = context.currentTokenParent.parent;
+                    if (blockParent.kind !== SyntaxKind.ArrowFunction &&
+                        blockParent.kind !== SyntaxKind.FunctionExpression
+                    ) {
+                        return true;
+                    }
+                }
             }
             return false;
         }
@@ -829,6 +852,7 @@ namespace ts.formatting {
             switch (parent.kind) {
                 case SyntaxKind.TypeReference:
                 case SyntaxKind.TypeAssertionExpression:
+                case SyntaxKind.TypeAliasDeclaration:
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.ClassExpression:
                 case SyntaxKind.InterfaceDeclaration:
@@ -865,5 +889,9 @@ namespace ts.formatting {
         static IsYieldOrYieldStarWithOperand(context: FormattingContext): boolean {
             return context.contextNode.kind === SyntaxKind.YieldExpression && (<YieldExpression>context.contextNode).expression !== undefined;
         }
+
+        static IsNonNullAssertionContext(context: FormattingContext): boolean {
+            return context.contextNode.kind === SyntaxKind.NonNullExpression;
+        }
     }
 }

src/services/formatting/rulesProvider.ts

@@ -38,6 +38,13 @@ namespace ts.formatting {
         private createActiveRules(options: ts.FormatCodeSettings): Rule[] {
             let rules = this.globalRules.HighPriorityCommonRules.slice(0);
 
+            if (options.insertSpaceAfterConstructor) {
+                rules.push(this.globalRules.SpaceAfterConstructor);
+            }
+            else {
+                rules.push(this.globalRules.NoSpaceAfterConstructor);
+            }
+
             if (options.insertSpaceAfterCommaDelimiter) {
                 rules.push(this.globalRules.SpaceAfterComma);
             }
@@ -128,6 +135,13 @@ namespace ts.formatting {
                 rules.push(this.globalRules.NoSpaceAfterBinaryOperator);
             }
 
+            if (options.insertSpaceBeforeFunctionParenthesis) {
+                rules.push(this.globalRules.SpaceBeforeOpenParenInFuncDecl);
+            }
+            else {
+                rules.push(this.globalRules.NoSpaceBeforeOpenParenInFuncDecl);
+            }
+
             if (options.placeOpenBraceOnNewLineForControlBlocks) {
                 rules.push(this.globalRules.NewLineBeforeOpenBraceInControl);
             }

src/services/formatting/smartIndenter.ts

@@ -438,6 +438,7 @@ namespace ts.formatting {
                 case SyntaxKind.ModuleBlock:
                 case SyntaxKind.ObjectLiteralExpression:
                 case SyntaxKind.TypeLiteral:
+                case SyntaxKind.MappedType:
                 case SyntaxKind.TupleType:
                 case SyntaxKind.CaseBlock:
                 case SyntaxKind.DefaultClause:

src/services/jsDoc.ts

@@ -1,4 +1,4 @@
-/* @internal */
+/* @internal */
 namespace ts.JsDoc {
     const jsDocTagNames = [
         "augments",
@@ -23,6 +23,7 @@ namespace ts.JsDoc {
         "lends",
         "link",
         "memberOf",
+        "method",
         "name",
         "namespace",
         "param",
@@ -75,7 +76,7 @@ namespace ts.JsDoc {
      */
     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++) {
+            for (let i = 0; i < array.length; i++) {
                 if (indexOf(array, array[i]) === i) {
                     const result = callback(array[i], i);
                     if (result) {
@@ -166,15 +167,20 @@ namespace ts.JsDoc {
         const lineStart = sourceFile.getLineStarts()[posLineAndChar.line];
 
         const indentationStr = sourceFile.text.substr(lineStart, posLineAndChar.character);
+        const isJavaScriptFile = hasJavaScriptFileExtension(sourceFile.fileName);
 
         let docParams = "";
-        for (let i = 0, numParams = parameters.length; i < numParams; i++) {
+        for (let i = 0; i < parameters.length; i++) {
             const currentName = parameters[i].name;
             const paramName = currentName.kind === SyntaxKind.Identifier ?
                 (<Identifier>currentName).text :
                 "param" + i;
-
-            docParams += `${indentationStr} * @param ${paramName}${newLine}`;
+            if (isJavaScriptFile) {
+                docParams += `${indentationStr} * @param {any} ${paramName}${newLine}`;
+            }
+            else {
+                docParams += `${indentationStr} * @param ${paramName}${newLine}`;
+            }
         }
 
         // A doc comment consists of the following

src/services/navigationBar.ts

@@ -146,7 +146,7 @@ namespace ts.NavigationBar {
                 break;
 
             case SyntaxKind.ImportClause:
-                let importClause = <ImportClause>node;
+                const importClause = <ImportClause>node;
                 // Handle default import case e.g.:
                 //    import d from "mod";
                 if (importClause.name) {

src/services/patternMatcher.ts

@@ -516,7 +516,8 @@ namespace ts {
 
     // Assumes 'value' is already lowercase.
     function indexOfIgnoringCase(string: string, value: string): number {
-        for (let i = 0, n = string.length - value.length; i <= n; i++) {
+        const n = string.length - value.length;
+        for (let i = 0; i <= n; i++) {
             if (startsWithIgnoringCase(string, value, i)) {
                 return i;
             }
@@ -527,7 +528,7 @@ namespace ts {
 
     // Assumes 'value' is already lowercase.
     function startsWithIgnoringCase(string: string, value: string, start: number): boolean {
-        for (let i = 0, n = value.length; i < n; i++) {
+        for (let i = 0; i < value.length; i++) {
             const ch1 = toLowerCase(string.charCodeAt(i + start));
             const ch2 = value.charCodeAt(i);
 
@@ -613,7 +614,7 @@ namespace ts {
         const result: TextSpan[] = [];
 
         let wordStart = 0;
-        for (let i = 1, n = identifier.length; i < n; i++) {
+        for (let i = 1; i < identifier.length; i++) {
             const lastIsDigit = isDigit(identifier.charCodeAt(i - 1));
             const currentIsDigit = isDigit(identifier.charCodeAt(i));
 

src/services/services.ts

@@ -24,7 +24,7 @@
 /// <reference path='transpile.ts' />
 /// <reference path='formatting\formatting.ts' />
 /// <reference path='formatting\smartIndenter.ts' />
-/// <reference path='codefixes\codeFixProvider.ts' />
+/// <reference path='codeFixProvider.ts' />
 /// <reference path='codefixes\fixes.ts' />
 
 namespace ts {
@@ -592,9 +592,8 @@ namespace ts {
                             else {
                                 declarations.push(functionDeclaration);
                             }
-
-                            forEachChild(node, visit);
                         }
+                        forEachChild(node, visit);
                         break;
 
                     case SyntaxKind.ClassDeclaration:
@@ -1725,7 +1724,7 @@ namespace ts {
             const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
 
             // Check if in a context where we don't want to perform any insertion
-            if (isInString(sourceFile, position) || isInComment(sourceFile, position)) {
+            if (isInString(sourceFile, position)) {
                 return false;
             }
 
@@ -1794,7 +1793,7 @@ namespace ts {
                     }
 
                     let descriptor: TodoCommentDescriptor = undefined;
-                    for (let i = 0, n = descriptors.length; i < n; i++) {
+                    for (let i = 0; i < descriptors.length; i++) {
                         if (matchArray[i + firstDescriptorCaptureIndex]) {
                             descriptor = descriptors[i];
                         }

src/services/shims.ts

@@ -1239,7 +1239,7 @@ namespace ts {
         }
 
         public unregisterShim(shim: Shim): void {
-            for (let i = 0, n = this._shims.length; i < n; i++) {
+            for (let i = 0; i < this._shims.length; i++) {
                 if (this._shims[i] === shim) {
                     delete this._shims[i];
                     return;

src/services/tsconfig.json

@@ -87,7 +87,15 @@
         "formatting/rulesProvider.ts",
         "formatting/smartIndenter.ts",
         "formatting/tokenRange.ts",
-        "codeFixes/codeFixProvider.ts",
-        "codeFixes/fixes.ts"
+        "codeFixProvider.ts",
+        "codefixes/fixExtendsInterfaceBecomesImplements.ts",
+        "codefixes/fixClassIncorrectlyImplementsInterface.ts",
+        "codefixes/fixClassDoesntImplementInheritedAbstractMember.ts",
+        "codefixes/fixClassSuperMustPrecedeThisAccess.ts",
+        "codefixes/fixConstructorForDerivedNeedSuperCall.ts",
+        "codefixes/fixes.ts",
+        "codefixes/helpers.ts",
+        "codefixes/importFixes.ts",
+        "codefixes/unusedIdentifierFixes.ts"
     ]
-}
+}

src/services/types.ts

@@ -91,7 +91,9 @@ namespace ts {
             }
 
             public getText(start: number, end: number): string {
-                return this.text.substring(start, end);
+                return start === 0 && end === this.text.length
+                    ? this.text
+                    : this.text.substring(start, end);
             }
 
             public getLength(): number {
@@ -416,6 +418,7 @@ namespace ts {
         InsertSpaceAfterCommaDelimiter: boolean;
         InsertSpaceAfterSemicolonInForStatements: boolean;
         InsertSpaceBeforeAndAfterBinaryOperators: boolean;
+        InsertSpaceAfterConstructor?: boolean;
         InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
         InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
         InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
@@ -424,6 +427,7 @@ namespace ts {
         InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
         InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
         InsertSpaceAfterTypeAssertion?: boolean;
+        InsertSpaceBeforeFunctionParenthesis?: boolean;
         PlaceOpenBraceOnNewLineForFunctions: boolean;
         PlaceOpenBraceOnNewLineForControlBlocks: boolean;
     }
@@ -432,6 +436,7 @@ namespace ts {
         insertSpaceAfterCommaDelimiter?: boolean;
         insertSpaceAfterSemicolonInForStatements?: boolean;
         insertSpaceBeforeAndAfterBinaryOperators?: boolean;
+        insertSpaceAfterConstructor?: boolean;
         insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
         insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
@@ -440,6 +445,7 @@ namespace ts {
         insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
         insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
         insertSpaceAfterTypeAssertion?: boolean;
+        insertSpaceBeforeFunctionParenthesis?: boolean;
         placeOpenBraceOnNewLineForFunctions?: boolean;
         placeOpenBraceOnNewLineForControlBlocks?: boolean;
     }

src/services/utilities.ts

@@ -675,8 +675,7 @@ namespace ts {
             }
 
             // find the child that contains 'position'
-            for (let i = 0, n = current.getChildCount(sourceFile); i < n; i++) {
-                const child = current.getChildAt(i);
+            for (const child of current.getChildren()) {
                 // all jsDocComment nodes were already visited
                 if (isJSDocNode(child)) {
                     continue;
@@ -766,7 +765,7 @@ namespace ts {
             }
 
             const children = n.getChildren();
-            for (let i = 0, len = children.length; i < len; i++) {
+            for (let i = 0; i < children.length; i++) {
                 const child = children[i];
                 // condition 'position < child.end' checks if child node end after the position
                 // in the example below this condition will be false for 'aaaa' and 'bbbb' and true for 'ccc'
@@ -1359,4 +1358,9 @@ namespace ts {
             diagnostics: error ? concatenate(diagnostics, [error]) : diagnostics
         };
     }
-}
+
+    export function getOpenBraceEnd(constructor: ConstructorDeclaration, sourceFile: SourceFile) {
+        // First token is the open curly, this is where we want to put the 'super' call.
+        return constructor.body.getFirstToken(sourceFile).getEnd();
+    }
+}