Merge remote-tracking branch 'refs/remotes/Microsoft/master' into indentSuppressor

src/compiler/binder.ts

@@ -1,3 +1,4 @@
+/// <reference path="utilities.ts"/>
 /// <reference path="parser.ts"/>
 
 /* @internal */
@@ -6,8 +7,23 @@ namespace ts {
 
     export const enum ModuleInstanceState {
         NonInstantiated = 0,
-        Instantiated    = 1,
-        ConstEnumOnly   = 2
+        Instantiated = 1,
+        ConstEnumOnly = 2
+    }
+
+    const enum Reachability {
+        Unintialized        = 1 << 0,
+        Reachable           = 1 << 1,
+        Unreachable         = 1 << 2,
+        ReportedUnreachable = 1 << 3
+    }
+
+    function or(state1: Reachability, state2: Reachability): Reachability {
+        return (state1 | state2) & Reachability.Reachable
+            ? Reachability.Reachable
+            : (state1 & state2) & Reachability.ReportedUnreachable
+                ? Reachability.ReportedUnreachable
+                : Reachability.Unreachable;
     }
 
     export function getModuleInstanceState(node: Node): ModuleInstanceState {
@@ -77,34 +93,66 @@ namespace ts {
         IsContainerWithLocals = IsContainer | HasLocals
     }
 
-    export function bindSourceFile(file: SourceFile) {
-        let start = new Date().getTime();
-        bindSourceFileWorker(file);
+    const binder = createBinder();
+
+    export function bindSourceFile(file: SourceFile, options: CompilerOptions) {
+        const start = new Date().getTime();
+        binder(file, options);
         bindTime += new Date().getTime() - start;
     }
 
-    function bindSourceFileWorker(file: SourceFile) {
+    function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
+        let file: SourceFile;
+        let options: CompilerOptions;
         let parent: Node;
         let container: Node;
         let blockScopeContainer: Node;
         let lastContainer: Node;
+        let seenThisKeyword: boolean;
+
+        // state used by reachability checks
+        let hasExplicitReturn: boolean;
+        let currentReachabilityState: Reachability;
+        let labelStack: Reachability[];
+        let labelIndexMap: Map<number>;
+        let implicitLabels: number[];
 
         // If this file is an external module, then it is automatically in strict-mode according to
         // ES6.  If it is not an external module, then we'll determine if it is in strict mode or
         // not depending on if we see "use strict" in certain places (or if we hit a class/namespace).
-        let inStrictMode = !!file.externalModuleIndicator;
+        let inStrictMode: boolean;
 
         let symbolCount = 0;
-        let Symbol = objectAllocator.getSymbolConstructor();
-        let classifiableNames: Map<string> = {};
+        let Symbol: { new (flags: SymbolFlags, name: string): Symbol };
+        let classifiableNames: Map<string>;
 
-        if (!file.locals) {
-            bind(file);
-            file.symbolCount = symbolCount;
-            file.classifiableNames = classifiableNames;
+        function bindSourceFile(f: SourceFile, opts: CompilerOptions) {
+            file = f;
+            options = opts;
+            inStrictMode = !!file.externalModuleIndicator;
+            classifiableNames = {};
+            Symbol = objectAllocator.getSymbolConstructor();
+
+            if (!file.locals) {
+                bind(file);
+                file.symbolCount = symbolCount;
+                file.classifiableNames = classifiableNames;
+            }
+
+            file = undefined;
+            options = undefined;
+            parent = undefined;
+            container = undefined;
+            blockScopeContainer = undefined;
+            lastContainer = undefined;
+            seenThisKeyword = false;
+            hasExplicitReturn = false;
+            labelStack = undefined;
+            labelIndexMap = undefined;
+            implicitLabels = undefined;
         }
 
-        return;
+        return bindSourceFile;
 
         function createSymbol(flags: SymbolFlags, name: string): Symbol {
             symbolCount++;
@@ -129,9 +177,14 @@ namespace ts {
                 symbol.members = {};
             }
 
-            if (symbolFlags & SymbolFlags.Value && !symbol.valueDeclaration) {
-                symbol.valueDeclaration = node;
-            }
+            if (symbolFlags & SymbolFlags.Value) {
+                const valueDeclaration = symbol.valueDeclaration;
+                if (!valueDeclaration ||
+                    (valueDeclaration.kind !== node.kind && valueDeclaration.kind === SyntaxKind.ModuleDeclaration)) {
+                    // other kinds of value declarations take precedence over modules
+                    symbol.valueDeclaration = node;
+                }
+        }
         }
 
         // Should not be called on a declaration with a computed property name,
@@ -142,7 +195,12 @@ namespace ts {
                     return `"${(<LiteralExpression>node.name).text}"`;
                 }
                 if (node.name.kind === SyntaxKind.ComputedPropertyName) {
-                    let nameExpression = (<ComputedPropertyName>node.name).expression;
+                    const nameExpression = (<ComputedPropertyName>node.name).expression;
+                    // treat computed property names where expression is string/numeric literal as just string/numeric literal
+                    if (isStringOrNumericLiteral(nameExpression.kind)) {
+                        return (<LiteralExpression>nameExpression).text;
+                    }
+
                     Debug.assert(isWellKnownSymbolSyntactically(nameExpression));
                     return getPropertyNameForKnownSymbolName((<PropertyAccessExpression>nameExpression).name.text);
                 }
@@ -163,6 +221,9 @@ namespace ts {
                     return "__export";
                 case SyntaxKind.ExportAssignment:
                     return (<ExportAssignment>node).isExportEquals ? "export=" : "default";
+                case SyntaxKind.BinaryExpression:
+                    // Binary expression case is for JS module 'module.exports = expr'
+                    return "export=";
                 case SyntaxKind.FunctionDeclaration:
                 case SyntaxKind.ClassDeclaration:
                     return node.flags & NodeFlags.Default ? "default" : undefined;
@@ -184,8 +245,9 @@ namespace ts {
         function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
             Debug.assert(!hasDynamicName(node));
 
+            const isDefaultExport = node.flags & NodeFlags.Default;
             // The exported symbol for an export default function/class node is always named "default"
-            let name = node.flags & NodeFlags.Default && parent ? "default" : getDeclarationName(node);
+            const name = isDefaultExport && parent ? "default" : getDeclarationName(node);
 
             let symbol: Symbol;
             if (name !== undefined) {
@@ -226,6 +288,13 @@ namespace ts {
                     let message = symbol.flags & SymbolFlags.BlockScopedVariable
                         ? Diagnostics.Cannot_redeclare_block_scoped_variable_0
                         : Diagnostics.Duplicate_identifier_0;
+
+                    forEach(symbol.declarations, declaration => {
+                        if (declaration.flags & NodeFlags.Default) {
+                            message = Diagnostics.A_module_cannot_have_multiple_default_exports;
+                        }
+                    });
+
                     forEach(symbol.declarations, declaration => {
                         file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration)));
                     });
@@ -245,7 +314,7 @@ namespace ts {
         }
 
         function declareModuleMember(node: Declaration, symbolFlags: SymbolFlags, symbolExcludes: SymbolFlags): Symbol {
-            let hasExportModifier = getCombinedNodeFlags(node) & NodeFlags.Export;
+            const hasExportModifier = getCombinedNodeFlags(node) & NodeFlags.Export;
             if (symbolFlags & SymbolFlags.Alias) {
                 if (node.kind === SyntaxKind.ExportSpecifier || (node.kind === SyntaxKind.ImportEqualsDeclaration && hasExportModifier)) {
                     return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
@@ -267,11 +336,11 @@ namespace ts {
                 //      but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way
                 //      when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope.
                 if (hasExportModifier || container.flags & NodeFlags.ExportContext) {
-                    let exportKind =
+                    const exportKind =
                         (symbolFlags & SymbolFlags.Value ? SymbolFlags.ExportValue : 0) |
                         (symbolFlags & SymbolFlags.Type ? SymbolFlags.ExportType : 0) |
                         (symbolFlags & SymbolFlags.Namespace ? SymbolFlags.ExportNamespace : 0);
-                    let local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
+                    const local = declareSymbol(container.locals, undefined, node, exportKind, symbolExcludes);
                     local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
                     node.localSymbol = local;
                     return local;
@@ -289,9 +358,9 @@ namespace ts {
             // Before we recurse into a node's chilren, we first save the existing parent, container
             // and block-container.  Then after we pop out of processing the children, we restore
             // these saved values.
-            let saveParent = parent;
-            let saveContainer = container;
-            let savedBlockScopeContainer = blockScopeContainer;
+            const saveParent = parent;
+            const saveContainer = container;
+            const savedBlockScopeContainer = blockScopeContainer;
 
             // This node will now be set as the parent of all of its children as we recurse into them.
             parent = node;
@@ -313,7 +382,7 @@ namespace ts {
             // reusing a node from a previous compilation, that node may have had 'locals' created
             // for it.  We must clear this so we don't accidently move any stale data forward from
             // a previous compilation.
-            let containerFlags = getContainerFlags(node);
+            const containerFlags = getContainerFlags(node);
             if (containerFlags & ContainerFlags.IsContainer) {
                 container = blockScopeContainer = node;
 
@@ -329,13 +398,277 @@ namespace ts {
                 blockScopeContainer.locals = undefined;
             }
 
-            forEachChild(node, bind);
+            let savedReachabilityState: Reachability;
+            let savedLabelStack: Reachability[];
+            let savedLabels: Map<number>;
+            let savedImplicitLabels: number[];
+            let savedHasExplicitReturn: boolean;
+
+            const kind = node.kind;
+            let flags = node.flags;
+
+            // reset all reachability check related flags on node (for incremental scenarios)
+            flags &= ~NodeFlags.ReachabilityCheckFlags;
+
+            if (kind === SyntaxKind.InterfaceDeclaration) {
+                seenThisKeyword = false;
+            }
+
+            const saveState = kind === SyntaxKind.SourceFile || kind === SyntaxKind.ModuleBlock || isFunctionLikeKind(kind);
+            if (saveState) {
+                savedReachabilityState = currentReachabilityState;
+                savedLabelStack = labelStack;
+                savedLabels = labelIndexMap;
+                savedImplicitLabels = implicitLabels;
+                savedHasExplicitReturn = hasExplicitReturn;
+
+                currentReachabilityState = Reachability.Reachable;
+                hasExplicitReturn = false;
+                labelStack = labelIndexMap = implicitLabels = undefined;
+            }
+
+            bindReachableStatement(node);
+
+            if (currentReachabilityState === Reachability.Reachable && isFunctionLikeKind(kind) && nodeIsPresent((<FunctionLikeDeclaration>node).body)) {
+                flags |= NodeFlags.HasImplicitReturn;
+                if (hasExplicitReturn) {
+                    flags |= NodeFlags.HasExplicitReturn;
+                }
+            }
+
+            if (kind === SyntaxKind.InterfaceDeclaration) {
+                flags = seenThisKeyword ? flags | NodeFlags.ContainsThis : flags & ~NodeFlags.ContainsThis;
+            }
+
+            node.flags = flags;
+
+            if (saveState) {
+                hasExplicitReturn = savedHasExplicitReturn;
+                currentReachabilityState = savedReachabilityState;
+                labelStack = savedLabelStack;
+                labelIndexMap = savedLabels;
+                implicitLabels = savedImplicitLabels;
+            }
 
             container = saveContainer;
             parent = saveParent;
             blockScopeContainer = savedBlockScopeContainer;
         }
 
+        /**
+         * Returns true if node and its subnodes were successfully traversed.
+         * Returning false means that node was not examined and caller needs to dive into the node himself.
+         */
+        function bindReachableStatement(node: Node): void {
+            if (checkUnreachable(node)) {
+                forEachChild(node, bind);
+                return;
+            }
+
+            switch (node.kind) {
+                case SyntaxKind.WhileStatement:
+                    bindWhileStatement(<WhileStatement>node);
+                    break;
+                case SyntaxKind.DoStatement:
+                    bindDoStatement(<DoStatement>node);
+                    break;
+                case SyntaxKind.ForStatement:
+                    bindForStatement(<ForStatement>node);
+                    break;
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.ForOfStatement:
+                    bindForInOrForOfStatement(<ForInStatement | ForOfStatement>node);
+                    break;
+                case SyntaxKind.IfStatement:
+                    bindIfStatement(<IfStatement>node);
+                    break;
+                case SyntaxKind.ReturnStatement:
+                case SyntaxKind.ThrowStatement:
+                    bindReturnOrThrow(<ReturnStatement | ThrowStatement>node);
+                    break;
+                case SyntaxKind.BreakStatement:
+                case SyntaxKind.ContinueStatement:
+                    bindBreakOrContinueStatement(<BreakOrContinueStatement>node);
+                    break;
+                case SyntaxKind.TryStatement:
+                    bindTryStatement(<TryStatement>node);
+                    break;
+                case SyntaxKind.SwitchStatement:
+                    bindSwitchStatement(<SwitchStatement>node);
+                    break;
+                case SyntaxKind.CaseBlock:
+                    bindCaseBlock(<CaseBlock>node);
+                    break;
+                case SyntaxKind.LabeledStatement:
+                    bindLabeledStatement(<LabeledStatement>node);
+                    break;
+                default:
+                    forEachChild(node, bind);
+                    break;
+            }
+        }
+
+        function bindWhileStatement(n: WhileStatement): void {
+            const preWhileState =
+                n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState;
+            const postWhileState =
+                n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : currentReachabilityState;
+
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+
+            currentReachabilityState = preWhileState;
+            const postWhileLabel = pushImplicitLabel();
+            bind(n.statement);
+            popImplicitLabel(postWhileLabel, postWhileState);
+        }
+
+        function bindDoStatement(n: DoStatement): void {
+            const preDoState = currentReachabilityState;
+
+            const postDoLabel = pushImplicitLabel();
+            bind(n.statement);
+            const postDoState = n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : preDoState;
+            popImplicitLabel(postDoLabel, postDoState);
+
+            // bind expressions (don't affect reachability)
+            bind(n.expression);
+        }
+
+        function bindForStatement(n: ForStatement): void {
+            const preForState = currentReachabilityState;
+            const postForLabel = pushImplicitLabel();
+
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.condition);
+            bind(n.incrementor);
+
+            bind(n.statement);
+
+            // for statement is considered infinite when it condition is either omitted or is true keyword
+            // - for(..;;..)
+            // - for(..;true;..)
+            const isInfiniteLoop = (!n.condition || n.condition.kind === SyntaxKind.TrueKeyword);
+            const postForState = isInfiniteLoop ? Reachability.Unreachable : preForState;
+            popImplicitLabel(postForLabel, postForState);
+        }
+
+        function bindForInOrForOfStatement(n: ForInStatement | ForOfStatement): void {
+            const preStatementState = currentReachabilityState;
+            const postStatementLabel = pushImplicitLabel();
+
+            // bind expressions (don't affect reachability)
+            bind(n.initializer);
+            bind(n.expression);
+
+            bind(n.statement);
+            popImplicitLabel(postStatementLabel, preStatementState);
+        }
+
+        function bindIfStatement(n: IfStatement): void {
+            // denotes reachability state when entering 'thenStatement' part of the if statement:
+            // i.e. if condition is false then thenStatement is unreachable
+            const ifTrueState = n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState;
+            // denotes reachability state when entering 'elseStatement':
+            // i.e. if condition is true then elseStatement is unreachable
+            const ifFalseState = n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : currentReachabilityState;
+
+            currentReachabilityState = ifTrueState;
+
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+
+            bind(n.thenStatement);
+            if (n.elseStatement) {
+                const preElseState = currentReachabilityState;
+                currentReachabilityState = ifFalseState;
+                bind(n.elseStatement);
+                currentReachabilityState = or(currentReachabilityState, preElseState);
+            }
+            else {
+                currentReachabilityState = or(currentReachabilityState, ifFalseState);
+            }
+        }
+
+        function bindReturnOrThrow(n: ReturnStatement | ThrowStatement): void {
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+            if (n.kind === SyntaxKind.ReturnStatement) {
+                hasExplicitReturn = true;
+            }
+            currentReachabilityState = Reachability.Unreachable;
+        }
+
+        function bindBreakOrContinueStatement(n: BreakOrContinueStatement): void {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+            // for continue case touch label so it will be marked a used
+            const isValidJump = jumpToLabel(n.label, n.kind === SyntaxKind.BreakStatement ? currentReachabilityState : Reachability.Unreachable);
+            if (isValidJump) {
+                currentReachabilityState = Reachability.Unreachable;
+            }
+        }
+
+        function bindTryStatement(n: TryStatement): void {
+            // catch\finally blocks has the same reachability as try block
+            const preTryState = currentReachabilityState;
+            bind(n.tryBlock);
+            const postTryState = currentReachabilityState;
+
+            currentReachabilityState = preTryState;
+            bind(n.catchClause);
+            const postCatchState = currentReachabilityState;
+
+            currentReachabilityState = preTryState;
+            bind(n.finallyBlock);
+
+            // post catch/finally state is reachable if
+            // - post try state is reachable - control flow can fall out of try block
+            // - post catch state is reachable - control flow can fall out of catch block
+            currentReachabilityState = or(postTryState, postCatchState);
+        }
+
+        function bindSwitchStatement(n: SwitchStatement): void {
+            const preSwitchState = currentReachabilityState;
+            const postSwitchLabel = pushImplicitLabel();
+
+            // bind expression (don't affect reachability)
+            bind(n.expression);
+
+            bind(n.caseBlock);
+
+            const hasDefault = forEach(n.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause);
+
+            // post switch state is unreachable if switch is exaustive (has a default case ) and does not have fallthrough from the last case
+            const postSwitchState = hasDefault && currentReachabilityState !== Reachability.Reachable ? Reachability.Unreachable : preSwitchState;
+
+            popImplicitLabel(postSwitchLabel, postSwitchState);
+        }
+
+        function bindCaseBlock(n: CaseBlock): void {
+            const startState = currentReachabilityState;
+
+            for (const clause of n.clauses) {
+                currentReachabilityState = startState;
+                bind(clause);
+                if (clause.statements.length && currentReachabilityState === Reachability.Reachable && options.noFallthroughCasesInSwitch) {
+                    errorOnFirstToken(clause, Diagnostics.Fallthrough_case_in_switch);
+                }
+            }
+        }
+
+        function bindLabeledStatement(n: LabeledStatement): void {
+            // call bind on label (don't affect reachability)
+            bind(n.label);
+
+            const ok = pushNamedLabel(n.label);
+            bind(n.statement);
+            if (ok) {
+                popNamedLabel(n.label, currentReachabilityState);
+            }
+        }
+
         function getContainerFlags(node: Node): ContainerFlags {
             switch (node.kind) {
                 case SyntaxKind.ClassExpression:
@@ -472,21 +805,10 @@ namespace ts {
                 : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes);
         }
 
-        function isAmbientContext(node: Node): boolean {
-            while (node) {
-                if (node.flags & NodeFlags.Ambient) {
-                    return true;
-                }
-
-                node = node.parent;
-            }
-            return false;
-        }
-
         function hasExportDeclarations(node: ModuleDeclaration | SourceFile): boolean {
-            let body = node.kind === SyntaxKind.SourceFile ? node : (<ModuleDeclaration>node).body;
+            const body = node.kind === SyntaxKind.SourceFile ? node : (<ModuleDeclaration>node).body;
             if (body.kind === SyntaxKind.SourceFile || body.kind === SyntaxKind.ModuleBlock) {
-                for (let stat of (<Block>body).statements) {
+                for (const stat of (<Block>body).statements) {
                     if (stat.kind === SyntaxKind.ExportDeclaration || stat.kind === SyntaxKind.ExportAssignment) {
                         return true;
                     }
@@ -498,7 +820,7 @@ namespace ts {
         function setExportContextFlag(node: ModuleDeclaration | SourceFile) {
             // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular
             // declarations with export modifiers) is an export context in which declarations are implicitly exported.
-            if (isAmbientContext(node) && !hasExportDeclarations(node)) {
+            if (isInAmbientContext(node) && !hasExportDeclarations(node)) {
                 node.flags |= NodeFlags.ExportContext;
             }
             else {
@@ -512,7 +834,7 @@ namespace ts {
                 declareSymbolAndAddToSymbolTable(node, SymbolFlags.ValueModule, SymbolFlags.ValueModuleExcludes);
             }
             else {
-                let state = getModuleInstanceState(node);
+                const state = getModuleInstanceState(node);
                 if (state === ModuleInstanceState.NonInstantiated) {
                     declareSymbolAndAddToSymbolTable(node, SymbolFlags.NamespaceModule, SymbolFlags.NamespaceModuleExcludes);
                 }
@@ -524,7 +846,7 @@ namespace ts {
                         node.symbol.constEnumOnlyModule = false;
                     }
                     else {
-                        let currentModuleIsConstEnumOnly = state === ModuleInstanceState.ConstEnumOnly;
+                        const currentModuleIsConstEnumOnly = state === ModuleInstanceState.ConstEnumOnly;
                         if (node.symbol.constEnumOnlyModule === undefined) {
                             // non-merged case - use the current state
                             node.symbol.constEnumOnlyModule = currentModuleIsConstEnumOnly;
@@ -545,10 +867,10 @@ namespace ts {
             // We do that by making an anonymous type literal symbol, and then setting the function
             // symbol as its sole member. To the rest of the system, this symbol will be  indistinguishable
             // from an actual type literal symbol you would have gotten had you used the long form.
-            let symbol = createSymbol(SymbolFlags.Signature, getDeclarationName(node));
+            const symbol = createSymbol(SymbolFlags.Signature, getDeclarationName(node));
             addDeclarationToSymbol(symbol, node, SymbolFlags.Signature);
 
-            let typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
+            const typeLiteralSymbol = createSymbol(SymbolFlags.TypeLiteral, "__type");
             addDeclarationToSymbol(typeLiteralSymbol, node, SymbolFlags.TypeLiteral);
             typeLiteralSymbol.members = { [symbol.name]: symbol };
         }
@@ -560,14 +882,14 @@ namespace ts {
             }
 
             if (inStrictMode) {
-                let seen: Map<ElementKind> = {};
+                const seen: Map<ElementKind> = {};
 
-                for (let prop of node.properties) {
+                for (const prop of node.properties) {
                     if (prop.name.kind !== SyntaxKind.Identifier) {
                         continue;
                     }
 
-                    let identifier = <Identifier>prop.name;
+                    const identifier = <Identifier>prop.name;
 
                     // ECMA-262 11.1.5 Object Initialiser
                     // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true
@@ -577,18 +899,18 @@ namespace ts {
                     //    c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true.
                     //    d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true
                     // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields
-                    let currentKind = prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment || prop.kind === SyntaxKind.MethodDeclaration
+                    const currentKind = prop.kind === SyntaxKind.PropertyAssignment || prop.kind === SyntaxKind.ShorthandPropertyAssignment || prop.kind === SyntaxKind.MethodDeclaration
                         ? ElementKind.Property
                         : ElementKind.Accessor;
 
-                    let existingKind = seen[identifier.text];
+                    const existingKind = seen[identifier.text];
                     if (!existingKind) {
                         seen[identifier.text] = currentKind;
                         continue;
                     }
 
                     if (currentKind === ElementKind.Property && existingKind === ElementKind.Property) {
-                        let span = getErrorSpanForNode(file, identifier);
+                        const span = getErrorSpanForNode(file, identifier);
                         file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length,
                             Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode));
                     }
@@ -599,7 +921,7 @@ namespace ts {
         }
 
         function bindAnonymousDeclaration(node: Declaration, symbolFlags: SymbolFlags, name: string) {
-            let symbol = createSymbol(symbolFlags, name);
+            const symbol = createSymbol(symbolFlags, name);
             addDeclarationToSymbol(symbol, node, symbolFlags);
         }
 
@@ -678,7 +1000,7 @@ namespace ts {
             if (inStrictMode && node.expression.kind === SyntaxKind.Identifier) {
                 // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its
                 // UnaryExpression is a direct reference to a variable, function argument, or function name
-                let span = getErrorSpanForNode(file, node.expression);
+                const span = getErrorSpanForNode(file, node.expression);
                 file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
             }
         }
@@ -690,11 +1012,11 @@ namespace ts {
 
         function checkStrictModeEvalOrArguments(contextNode: Node, name: Node) {
             if (name && name.kind === SyntaxKind.Identifier) {
-                let identifier = <Identifier>name;
+                const identifier = <Identifier>name;
                 if (isEvalOrArgumentsIdentifier(identifier)) {
                     // We check first if the name is inside class declaration or class expression; if so give explicit message
                     // otherwise report generic error message.
-                    let span = getErrorSpanForNode(file, name);
+                    const span = getErrorSpanForNode(file, name);
                     file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length,
                         getStrictModeEvalOrArgumentsMessage(contextNode), identifier.text));
                 }
@@ -750,12 +1072,12 @@ namespace ts {
         function checkStrictModeWithStatement(node: WithStatement) {
             // Grammar checking for withStatement
             if (inStrictMode) {
-                grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
+                errorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
             }
         }
 
-        function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any) {
-            let span = getSpanOfTokenAtPosition(file, node.pos);
+        function errorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any) {
+            const span = getSpanOfTokenAtPosition(file, node.pos);
             file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
         }
 
@@ -763,10 +1085,14 @@ namespace ts {
             return "__" + indexOf((<SignatureDeclaration>node.parent).parameters, node);
         }
 
-        function bind(node: Node) {
+        function bind(node: Node): void {
+            if (!node) {
+                return;
+            }
+
             node.parent = parent;
 
-            let savedInStrictMode = inStrictMode;
+            const savedInStrictMode = inStrictMode;
             if (!savedInStrictMode) {
                 updateStrictMode(node);
             }
@@ -812,7 +1138,7 @@ namespace ts {
         }
 
         function updateStrictModeStatementList(statements: NodeArray<Statement>) {
-            for (let statement of statements) {
+            for (const statement of statements) {
                 if (!isPrologueDirective(statement)) {
                     return;
                 }
@@ -826,7 +1152,7 @@ namespace ts {
 
         /// Should be called only on prologue directives (isPrologueDirective(node) should be true)
         function isUseStrictPrologueDirective(node: ExpressionStatement): boolean {
-            let nodeText = getTextOfNodeFromSourceText(file.text, node.expression);
+            const nodeText = getTextOfNodeFromSourceText(file.text, node.expression);
 
             // Note: the node text must be exactly "use strict" or 'use strict'.  It is not ok for the
             // string to contain unicode escapes (as per ES5).
@@ -835,9 +1161,18 @@ namespace ts {
 
         function bindWorker(node: Node) {
             switch (node.kind) {
+                /* Strict mode checks */
                 case SyntaxKind.Identifier:
                     return checkStrictModeIdentifier(<Identifier>node);
                 case SyntaxKind.BinaryExpression:
+                    if (isInJavaScriptFile(node)) {
+                        if (isExportsPropertyAssignment(node)) {
+                            bindExportsPropertyAssignment(<BinaryExpression>node);
+                        }
+                        else if (isModuleExportsAssignment(node)) {
+                            bindModuleExportsAssignment(<BinaryExpression>node);
+                        }
+                    }
                     return checkStrictModeBinaryExpression(<BinaryExpression>node);
                 case SyntaxKind.CatchClause:
                     return checkStrictModeCatchClause(<CatchClause>node);
@@ -851,6 +1186,9 @@ namespace ts {
                     return checkStrictModePrefixUnaryExpression(<PrefixUnaryExpression>node);
                 case SyntaxKind.WithStatement:
                     return checkStrictModeWithStatement(<WithStatement>node);
+                case SyntaxKind.ThisType:
+                    seenThisKeyword = true;
+                    return;
 
                 case SyntaxKind.TypeParameter:
                     return declareSymbolAndAddToSymbolTable(<Declaration>node, SymbolFlags.TypeParameter, SymbolFlags.TypeParameterExcludes);
@@ -898,8 +1236,16 @@ namespace ts {
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
                     checkStrictModeFunctionName(<FunctionExpression>node);
-                    let bindingName = (<FunctionExpression>node).name ? (<FunctionExpression>node).name.text : "__function";
+                    const bindingName = (<FunctionExpression>node).name ? (<FunctionExpression>node).name.text : "__function";
                     return bindAnonymousDeclaration(<FunctionExpression>node, SymbolFlags.Function, bindingName);
+
+                case SyntaxKind.CallExpression:
+                    if (isInJavaScriptFile(node)) {
+                        bindCallExpression(<CallExpression>node);
+                    }
+                    break;
+
+                // Members of classes, interfaces, and modules
                 case SyntaxKind.ClassExpression:
                 case SyntaxKind.ClassDeclaration:
                     return bindClassLikeDeclaration(<ClassLikeDeclaration>node);
@@ -911,6 +1257,8 @@ namespace ts {
                     return bindEnumDeclaration(<EnumDeclaration>node);
                 case SyntaxKind.ModuleDeclaration:
                     return bindModuleDeclaration(<ModuleDeclaration>node);
+
+                // Imports and exports
                 case SyntaxKind.ImportEqualsDeclaration:
                 case SyntaxKind.NamespaceImport:
                 case SyntaxKind.ImportSpecifier:
@@ -930,16 +1278,21 @@ namespace ts {
         function bindSourceFileIfExternalModule() {
             setExportContextFlag(file);
             if (isExternalModule(file)) {
-                bindAnonymousDeclaration(file, SymbolFlags.ValueModule, `"${removeFileExtension(file.fileName)}"`);
+                bindSourceFileAsExternalModule();
             }
         }
 
-        function bindExportAssignment(node: ExportAssignment) {
+        function bindSourceFileAsExternalModule() {
+            bindAnonymousDeclaration(file, SymbolFlags.ValueModule, `"${removeFileExtension(file.fileName) }"`);
+        }
+
+        function bindExportAssignment(node: ExportAssignment | BinaryExpression) {
+            const boundExpression = node.kind === SyntaxKind.ExportAssignment ? (<ExportAssignment>node).expression : (<BinaryExpression>node).right;
             if (!container.symbol || !container.symbol.exports) {
                 // Export assignment in some sort of block construct
                 bindAnonymousDeclaration(node, SymbolFlags.Alias, getDeclarationName(node));
             }
-            else if (node.expression.kind === SyntaxKind.Identifier) {
+            else if (boundExpression.kind === SyntaxKind.Identifier) {
                 // An export default clause with an identifier exports all meanings of that identifier
                 declareSymbol(container.symbol.exports, container.symbol, node, SymbolFlags.Alias, SymbolFlags.PropertyExcludes | SymbolFlags.AliasExcludes);
             }
@@ -966,12 +1319,40 @@ namespace ts {
             }
         }
 
+        function setCommonJsModuleIndicator(node: Node) {
+            if (!file.commonJsModuleIndicator) {
+                file.commonJsModuleIndicator = node;
+                bindSourceFileAsExternalModule();
+            }
+        }
+
+        function bindExportsPropertyAssignment(node: BinaryExpression) {
+            // When we create a property via 'exports.foo = bar', the 'exports.foo' property access
+            // expression is the declaration
+            setCommonJsModuleIndicator(node);
+            declareSymbol(file.symbol.exports, file.symbol, <PropertyAccessExpression>node.left, SymbolFlags.Property | SymbolFlags.Export, SymbolFlags.None);
+        }
+
+        function bindModuleExportsAssignment(node: BinaryExpression) {
+            // 'module.exports = expr' assignment
+            setCommonJsModuleIndicator(node);
+            bindExportAssignment(node);
+        }
+
+        function bindCallExpression(node: CallExpression) {
+            // We're only inspecting call expressions to detect CommonJS modules, so we can skip
+            // this check if we've already seen the module indicator
+            if (!file.commonJsModuleIndicator && isRequireCall(node)) {
+                setCommonJsModuleIndicator(node);
+            }
+        }
+
         function bindClassLikeDeclaration(node: ClassLikeDeclaration) {
             if (node.kind === SyntaxKind.ClassDeclaration) {
                 bindBlockScopedDeclaration(node, SymbolFlags.Class, SymbolFlags.ClassExcludes);
             }
             else {
-                let bindingName = node.name ? node.name.text : "__class";
+                const bindingName = node.name ? node.name.text : "__class";
                 bindAnonymousDeclaration(node, SymbolFlags.Class, bindingName);
                 // Add name of class expression into the map for semantic classifier
                 if (node.name) {
@@ -979,7 +1360,7 @@ namespace ts {
                 }
             }
 
-            let symbol = node.symbol;
+            const symbol = node.symbol;
 
             // TypeScript 1.0 spec (April 2014): 8.4
             // Every class automatically contains a static property member named 'prototype', the
@@ -990,7 +1371,7 @@ namespace ts {
             // Note: we check for this here because this class may be merging into a module.  The
             // module might have an exported variable called 'prototype'.  We can't allow that as
             // that would clash with the built-in 'prototype' for the class.
-            let prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
+            const prototypeSymbol = createSymbol(SymbolFlags.Property | SymbolFlags.Prototype, "prototype");
             if (hasProperty(symbol.exports, prototypeSymbol.name)) {
                 if (node.name) {
                     node.name.parent = node;
@@ -1055,7 +1436,7 @@ namespace ts {
                 node.parent.kind === SyntaxKind.Constructor &&
                 isClassLike(node.parent.parent)) {
 
-                let classDeclaration = <ClassLikeDeclaration>node.parent.parent;
+                const classDeclaration = <ClassLikeDeclaration>node.parent.parent;
                 declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
             }
         }
@@ -1065,5 +1446,135 @@ namespace ts {
                 ? bindAnonymousDeclaration(node, symbolFlags, "__computed")
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
+
+        // reachability checks
+
+        function pushNamedLabel(name: Identifier): boolean {
+            initializeReachabilityStateIfNecessary();
+
+            if (hasProperty(labelIndexMap, name.text)) {
+                return false;
+            }
+            labelIndexMap[name.text] = labelStack.push(Reachability.Unintialized) - 1;
+            return true;
+        }
+
+        function pushImplicitLabel(): number {
+            initializeReachabilityStateIfNecessary();
+
+            const index = labelStack.push(Reachability.Unintialized) - 1;
+            implicitLabels.push(index);
+            return index;
+        }
+
+        function popNamedLabel(label: Identifier, outerState: Reachability): void {
+            const index = labelIndexMap[label.text];
+            Debug.assert(index !== undefined);
+            Debug.assert(labelStack.length == index + 1);
+
+            labelIndexMap[label.text] = undefined;
+
+            setCurrentStateAtLabel(labelStack.pop(), outerState, label);
+        }
+
+        function popImplicitLabel(implicitLabelIndex: number, outerState: Reachability): void {
+            if (labelStack.length !== implicitLabelIndex + 1) {
+                Debug.assert(false, `Label stack: ${labelStack.length}, index:${implicitLabelIndex}`);
+            }
+
+            const i = implicitLabels.pop();
+
+            if (implicitLabelIndex !== i) {
+                Debug.assert(false, `i: ${i}, index: ${implicitLabelIndex}`);
+            }
+
+            setCurrentStateAtLabel(labelStack.pop(), outerState, /*name*/ undefined);
+        }
+
+        function setCurrentStateAtLabel(innerMergedState: Reachability, outerState: Reachability, label: Identifier): void {
+            if (innerMergedState === Reachability.Unintialized) {
+                if (label && !options.allowUnusedLabels) {
+                    file.bindDiagnostics.push(createDiagnosticForNode(label, Diagnostics.Unused_label));
+                }
+                currentReachabilityState = outerState;
+            }
+            else {
+                currentReachabilityState = or(innerMergedState, outerState);
+            }
+        }
+
+        function jumpToLabel(label: Identifier, outerState: Reachability): boolean {
+            initializeReachabilityStateIfNecessary();
+
+            const index = label ? labelIndexMap[label.text] : lastOrUndefined(implicitLabels);
+            if (index === undefined) {
+                // reference to unknown label or
+                // break/continue used outside of loops
+                return false;
+            }
+            const stateAtLabel = labelStack[index];
+            labelStack[index] = stateAtLabel === Reachability.Unintialized ? outerState : or(stateAtLabel, outerState);
+            return true;
+        }
+
+        function checkUnreachable(node: Node): boolean {
+            switch (currentReachabilityState) {
+                case Reachability.Unreachable:
+                    const reportError =
+                        // report error on all statements except empty ones
+                        (isStatement(node) && node.kind !== SyntaxKind.EmptyStatement) ||
+                        // report error on class declarations
+                        node.kind === SyntaxKind.ClassDeclaration ||
+                        // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
+                        (node.kind === SyntaxKind.ModuleDeclaration && shouldReportErrorOnModuleDeclaration(<ModuleDeclaration>node)) ||
+                        // report error on regular enums and const enums if preserveConstEnums is set
+                        (node.kind === SyntaxKind.EnumDeclaration && (!isConstEnumDeclaration(node) || options.preserveConstEnums));
+
+                    if (reportError) {
+                        currentReachabilityState = Reachability.ReportedUnreachable;
+
+                        // unreachable code is reported if
+                        // - user has explicitly asked about it AND
+                        // - statement is in not ambient context (statements in ambient context is already an error
+                        //   so we should not report extras) AND
+                        //   - node is not variable statement OR
+                        //   - node is block scoped variable statement OR
+                        //   - node is not block scoped variable statement and at least one variable declaration has initializer
+                        //   Rationale: we don't want to report errors on non-initialized var's since they are hoisted
+                        //   On the other side we do want to report errors on non-initialized 'lets' because of TDZ
+                        const reportUnreachableCode =
+                            !options.allowUnreachableCode &&
+                            !isInAmbientContext(node) &&
+                            (
+                                node.kind !== SyntaxKind.VariableStatement ||
+                                getCombinedNodeFlags((<VariableStatement>node).declarationList) & NodeFlags.BlockScoped ||
+                                forEach((<VariableStatement>node).declarationList.declarations, d => d.initializer)
+                            );
+
+                        if (reportUnreachableCode) {
+                            errorOnFirstToken(node, Diagnostics.Unreachable_code_detected);
+                        }
+                    }
+                case Reachability.ReportedUnreachable:
+                    return true;
+                default:
+                    return false;
+            }
+
+            function shouldReportErrorOnModuleDeclaration(node: ModuleDeclaration): boolean {
+                const instanceState = getModuleInstanceState(node);
+                return instanceState === ModuleInstanceState.Instantiated || (instanceState === ModuleInstanceState.ConstEnumOnly && options.preserveConstEnums);
+            }
+        }
+
+        function initializeReachabilityStateIfNecessary(): void {
+            if (labelIndexMap) {
+                return;
+            }
+            currentReachabilityState = Reachability.Reachable;
+            labelIndexMap = {};
+            labelStack = [];
+            implicitLabels = [];
+        }
     }
 }

src/compiler/commandLineParser.ts

@@ -1,6 +1,7 @@
 /// <reference path="sys.ts"/>
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
+/// <reference path="diagnosticInformationMap.generated.ts"/>
 /// <reference path="scanner.ts"/>
 
 namespace ts {
@@ -76,10 +77,12 @@ namespace ts {
                 "amd": ModuleKind.AMD,
                 "system": ModuleKind.System,
                 "umd": ModuleKind.UMD,
+                "es6": ModuleKind.ES6,
+                "es2015": ModuleKind.ES2015,
             },
-            description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_or_umd,
+            description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
             paramType: Diagnostics.KIND,
-            error: Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_or_umd
+            error: Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_umd_or_es2015
         },
         {
             name: "newLine",
@@ -148,6 +151,12 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
         },
+        {
+            name: "pretty",
+            paramType: Diagnostics.KIND,
+            description: Diagnostics.Stylize_errors_and_messages_using_color_and_context_experimental,
+            type: "boolean"
+        },
         {
             name: "project",
             shortName: "p",
@@ -204,10 +213,15 @@ namespace ts {
         {
             name: "target",
             shortName: "t",
-            type: { "es3": ScriptTarget.ES3, "es5": ScriptTarget.ES5, "es6": ScriptTarget.ES6 },
-            description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental,
+            type: {
+                "es3": ScriptTarget.ES3,
+                "es5": ScriptTarget.ES5,
+                "es6": ScriptTarget.ES6,
+                "es2015": ScriptTarget.ES2015,
+            },
+            description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015_experimental,
             paramType: Diagnostics.VERSION,
-            error: Diagnostics.Argument_for_target_option_must_be_ES3_ES5_or_ES6
+            error: Diagnostics.Argument_for_target_option_must_be_ES3_ES5_or_ES2015
         },
         {
             name: "version",
@@ -221,11 +235,6 @@ namespace ts {
             type: "boolean",
             description: Diagnostics.Watch_input_files,
         },
-        {
-            name: "experimentalAsyncFunctions",
-            type: "boolean",
-            description: Diagnostics.Enables_experimental_support_for_ES7_async_functions
-        },
         {
             name: "experimentalDecorators",
             type: "boolean",
@@ -243,8 +252,39 @@ namespace ts {
                 "node": ModuleResolutionKind.NodeJs,
                 "classic": ModuleResolutionKind.Classic
             },
-            description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_or_classic_TypeScript_pre_1_6
-        }        
+            description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6,
+            error: Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic,
+        },
+        {
+            name: "allowUnusedLabels",
+            type: "boolean",
+            description: Diagnostics.Do_not_report_errors_on_unused_labels
+        },
+        {
+            name: "noImplicitReturns",
+            type: "boolean",
+            description: Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value
+        },
+        {
+            name: "noFallthroughCasesInSwitch",
+            type: "boolean",
+            description: Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement
+        },
+        {
+            name: "allowUnreachableCode",
+            type: "boolean",
+            description: Diagnostics.Do_not_report_errors_on_unreachable_code
+        },
+        {
+            name: "forceConsistentCasingInFileNames",
+            type: "boolean",
+            description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file
+        },
+        {
+            name: "allowJs",
+            type: "boolean",
+            description: Diagnostics.Allow_javascript_files_to_be_compiled,
+        }
     ];
 
     /* @internal */
@@ -260,8 +300,8 @@ namespace ts {
             return optionNameMapCache;
         }
 
-        let optionNameMap: Map<CommandLineOption> = {};
-        let shortOptionNames: Map<string> = {};
+        const optionNameMap: Map<CommandLineOption> = {};
+        const shortOptionNames: Map<string> = {};
         forEach(optionDeclarations, option => {
             optionNameMap[option.name.toLowerCase()] = option;
             if (option.shortName) {
@@ -274,10 +314,10 @@ namespace ts {
     }
 
     export function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine {
-        let options: CompilerOptions = {};
-        let fileNames: string[] = [];
-        let errors: Diagnostic[] = [];
-        let { optionNameMap, shortOptionNames } = getOptionNameMap();
+        const options: CompilerOptions = {};
+        const fileNames: string[] = [];
+        const errors: Diagnostic[] = [];
+        const { optionNameMap, shortOptionNames } = getOptionNameMap();
 
         parseStrings(commandLine);
         return {
@@ -302,7 +342,7 @@ namespace ts {
                     }
 
                     if (hasProperty(optionNameMap, s)) {
-                        let opt = optionNameMap[s];
+                        const opt = optionNameMap[s];
 
                         // Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).
                         if (!args[i] && opt.type !== "boolean") {
@@ -327,7 +367,7 @@ namespace ts {
                                     options[opt.name] = map[key];
                                 }
                                 else {
-                                    errors.push(createCompilerDiagnostic(opt.error));
+                                    errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));
                                 }
                         }
                     }
@@ -342,19 +382,19 @@ namespace ts {
         }
 
         function parseResponseFile(fileName: string) {
-            let text = readFile ? readFile(fileName) : sys.readFile(fileName);
+            const text = readFile ? readFile(fileName) : sys.readFile(fileName);
 
             if (!text) {
                 errors.push(createCompilerDiagnostic(Diagnostics.File_0_not_found, fileName));
                 return;
             }
 
-            let args: string[] = [];
+            const args: string[] = [];
             let pos = 0;
             while (true) {
                 while (pos < text.length && text.charCodeAt(pos) <= CharacterCodes.space) pos++;
                 if (pos >= text.length) break;
-                let start = pos;
+                const start = pos;
                 if (text.charCodeAt(start) === CharacterCodes.doubleQuote) {
                     pos++;
                     while (pos < text.length && text.charCodeAt(pos) !== CharacterCodes.doubleQuote) pos++;
@@ -387,7 +427,7 @@ namespace ts {
         catch (e) {
             return { error: createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message) };
         }
-        return parseConfigFileText(fileName, text);
+        return parseConfigFileTextToJson(fileName, text);
     }
 
     /**
@@ -395,72 +435,60 @@ namespace ts {
       * @param fileName The path to the config file
       * @param jsonText The text of the config file
       */
-    export function parseConfigFileText(fileName: string, jsonText: string): { config?: any; error?: Diagnostic } {
+    export function parseConfigFileTextToJson(fileName: string, jsonText: string): { config?: any; error?: Diagnostic } {
         try {
-            return { config: /\S/.test(jsonText) ? JSON.parse(jsonText) : {} };
+            const jsonTextWithoutComments = removeComments(jsonText);
+            return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };
         }
         catch (e) {
             return { error: createCompilerDiagnostic(Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };
         }
     }
 
+
+    /**
+     * Remove the comments from a json like text.
+     * Comments can be single line comments (starting with # or //) or multiline comments using / * * /
+     *
+     * This method replace comment content by whitespace rather than completely remove them to keep positions in json parsing error reporting accurate.
+     */
+    function removeComments(jsonText: string): string {
+        let output = "";
+        const scanner = createScanner(ScriptTarget.ES5, /* skipTrivia */ false, LanguageVariant.Standard, jsonText);
+        let token: SyntaxKind;
+        while ((token = scanner.scan()) !== SyntaxKind.EndOfFileToken) {
+            switch (token) {
+                case SyntaxKind.SingleLineCommentTrivia:
+                case SyntaxKind.MultiLineCommentTrivia:
+                    // replace comments with whitespace to preserve original character positions
+                    output += scanner.getTokenText().replace(/\S/g, " ");
+                    break;
+                default:
+                    output += scanner.getTokenText();
+                    break;
+            }
+        }
+        return output;
+    }
+
+
     /**
       * Parse the contents of a config file (tsconfig.json).
       * @param json The contents of the config file to parse
+      * @param host Instance of ParseConfigHost used to enumerate files in folder.
       * @param basePath A root directory to resolve relative path entries in the config
       *    file to. e.g. outDir
       */
-    export function parseConfigFile(json: any, host: ParseConfigHost, basePath: string): ParsedCommandLine {
-        let errors: Diagnostic[] = [];
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions: CompilerOptions = {}): ParsedCommandLine {
+        const { options: optionsFromJsonConfigFile, errors } = convertCompilerOptionsFromJson(json["compilerOptions"], basePath);
 
+        const options = extend(existingOptions, optionsFromJsonConfigFile);
         return {
-            options: getCompilerOptions(),
+            options,
             fileNames: getFileNames(),
             errors
         };
-
-        function getCompilerOptions(): CompilerOptions {
-            let options: CompilerOptions = {};
-            let optionNameMap: Map<CommandLineOption> = {};
-            forEach(optionDeclarations, option => {
-                optionNameMap[option.name] = option;
-            });
-            let jsonOptions = json["compilerOptions"];
-            if (jsonOptions) {
-                for (let id in jsonOptions) {
-                    if (hasProperty(optionNameMap, id)) {
-                        let opt = optionNameMap[id];
-                        let optType = opt.type;
-                        let value = jsonOptions[id];
-                        let expectedType = typeof optType === "string" ? optType : "string";
-                        if (typeof value === expectedType) {
-                            if (typeof optType !== "string") {
-                                let key = value.toLowerCase();
-                                if (hasProperty(optType, key)) {
-                                    value = optType[key];
-                                }
-                                else {
-                                    errors.push(createCompilerDiagnostic(opt.error));
-                                    value = 0;
-                                }
-                            }
-                            if (opt.isFilePath) {
-                                value = normalizePath(combinePaths(basePath, value));
-                            }
-                            options[opt.name] = value;
-                        }
-                        else {
-                            errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, id, expectedType));
-                        }
-                    }
-                    else {
-                        errors.push(createCompilerDiagnostic(Diagnostics.Unknown_compiler_option_0, id));
-                    }
-                }
-            }
-            return options;
-        }
-
+
         function getFileNames(): string[] {
             let fileNames: string[] = [];
             if (hasProperty(json, "files")) {
@@ -468,31 +496,87 @@ namespace ts {
                     fileNames = map(<string[]>json["files"], s => combinePaths(basePath, s));
                 }
                 else {
-                    errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array"));                    
+                    errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array"));
                 }
             }
             else {
-                let exclude = json["exclude"] instanceof Array ? map(<string[]>json["exclude"], normalizeSlashes) : undefined;
-                let sysFiles = host.readDirectory(basePath, ".ts", exclude).concat(host.readDirectory(basePath, ".tsx", exclude));
-                for (let i = 0; i < sysFiles.length; i++) {
-                    let name = sysFiles[i];
-                    if (fileExtensionIs(name, ".d.ts")) {
-                        let baseName = name.substr(0, name.length - ".d.ts".length);
-                        if (!contains(sysFiles, baseName + ".tsx") && !contains(sysFiles, baseName + ".ts")) {
-                            fileNames.push(name);
+                const filesSeen: Map<boolean> = {};
+                const exclude = json["exclude"] instanceof Array ? map(<string[]>json["exclude"], normalizeSlashes) : undefined;
+                const supportedExtensions = getSupportedExtensions(options);
+                Debug.assert(indexOf(supportedExtensions, ".ts") < indexOf(supportedExtensions, ".d.ts"), "Changed priority of extensions to pick");
+
+                // Get files of supported extensions in their order of resolution
+                for (const extension of supportedExtensions) {
+                    const filesInDirWithExtension = host.readDirectory(basePath, extension, exclude);
+                    for (const fileName of filesInDirWithExtension) {
+                        // .ts extension would read the .d.ts extension files too but since .d.ts is lower priority extension, 
+                        // lets pick them when its turn comes up
+                        if (extension === ".ts" && fileExtensionIs(fileName, ".d.ts")) {
+                            continue;
                         }
-                    }
-                    else if (fileExtensionIs(name, ".ts")) {
-                        if (!contains(sysFiles, name + "x")) {
-                            fileNames.push(name);
+
+                        // If this is one of the output extension (which would be .d.ts and .js if we are allowing compilation of js files)
+                        // do not include this file if we included .ts or .tsx file with same base name as it could be output of the earlier compilation
+                        if (extension === ".d.ts" || (options.allowJs && contains(supportedJavascriptExtensions, extension))) {
+                            const baseName = fileName.substr(0, fileName.length - extension.length);
+                            if (hasProperty(filesSeen, baseName + ".ts") || hasProperty(filesSeen, baseName + ".tsx")) {
+                                continue;
+                            }
                         }
-                    }
-                    else {
-                        fileNames.push(name);
+
+                        filesSeen[fileName] = true;
+                        fileNames.push(fileName);
                     }
                 }
             }
             return fileNames;
         }
     }
-}
+
+    export function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string): { options: CompilerOptions, errors: Diagnostic[] } {
+        const options: CompilerOptions = {};
+        const errors: Diagnostic[] = [];
+
+        if (!jsonOptions) {
+            return { options, errors };
+        }
+
+        const optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);
+
+        for (const id in jsonOptions) {
+            if (hasProperty(optionNameMap, id)) {
+                const opt = optionNameMap[id];
+                const optType = opt.type;
+                let value = jsonOptions[id];
+                const expectedType = typeof optType === "string" ? optType : "string";
+                if (typeof value === expectedType) {
+                    if (typeof optType !== "string") {
+                        const key = value.toLowerCase();
+                        if (hasProperty(optType, key)) {
+                            value = optType[key];
+                        }
+                        else {
+                            errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));
+                            value = 0;
+                        }
+                    }
+                    if (opt.isFilePath) {
+                        value = normalizePath(combinePaths(basePath, value));
+                        if (value === "") {
+                            value = ".";
+                        }
+                    }
+                    options[opt.name] = value;
+                }
+                else {
+                    errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, id, expectedType));
+                }
+            }
+            else {
+                errors.push(createCompilerDiagnostic(Diagnostics.Unknown_compiler_option_0, id));
+            }
+        }
+
+        return { options, errors };
+    }
+}

src/compiler/core.ts

@@ -17,45 +17,55 @@ namespace ts {
         True = -1
     }
 
-    export function createFileMap<T>(getCanonicalFileName: (fileName: string) => string): FileMap<T> {
+    export function createFileMap<T>(keyMapper?: (key: string) => string): FileMap<T> {
         let files: Map<T> = {};
         return {
             get,
             set,
             contains,
             remove,
-            clear,
-            forEachValue: forEachValueInMap
+            forEachValue: forEachValueInMap,
+            clear
         };
 
-        function set(fileName: string, value: T) {
-            files[normalizeKey(fileName)] = value;
+        function forEachValueInMap(f: (key: Path, value: T) => void) {
+            for (const key in files) {
+                f(<Path>key, files[key]);
+            }
         }
 
-        function get(fileName: string) {
-            return files[normalizeKey(fileName)];
+        // path should already be well-formed so it does not need to be normalized
+        function get(path: Path): T {
+            return files[toKey(path)];
         }
 
-        function contains(fileName: string) {
-            return hasProperty(files, normalizeKey(fileName));
+        function set(path: Path, value: T) {
+            files[toKey(path)] = value;
         }
 
-        function remove (fileName: string) {
-            let key = normalizeKey(fileName);
+        function contains(path: Path) {
+            return hasProperty(files, toKey(path));
+        }
+
+        function remove(path: Path) {
+            const key = toKey(path);
             delete files[key];
         }
 
-        function forEachValueInMap(f: (value: T) => void) {
-            forEachValue(files, f);
-        }
-
-        function normalizeKey(key: string) {
-            return getCanonicalFileName(normalizeSlashes(key));
-        }
-        
         function clear() {
             files = {};
         }
+
+        function toKey(path: Path): string {
+            return keyMapper ? keyMapper(path) : path;
+        }
+    }
+
+    export function toPath(fileName: string, basePath: string, getCanonicalFileName: (path: string) => string): Path {
+        const nonCanonicalizedPath = isRootedDiskPath(fileName)
+            ? normalizePath(fileName)
+            : getNormalizedAbsolutePath(fileName, basePath);
+        return <Path>getCanonicalFileName(nonCanonicalizedPath);
     }
 
     export const enum Comparison {
@@ -74,7 +84,7 @@ namespace ts {
     export function forEach<T, U>(array: T[], callback: (element: T, index: number) => U): U {
         if (array) {
             for (let i = 0, len = array.length; i < len; i++) {
-                let result = callback(array[i], i);
+                const result = callback(array[i], i);
                 if (result) {
                     return result;
                 }
@@ -85,7 +95,7 @@ namespace ts {
 
     export function contains<T>(array: T[], value: T): boolean {
         if (array) {
-            for (let v of array) {
+            for (const v of array) {
                 if (v === value) {
                     return true;
                 }
@@ -108,7 +118,7 @@ namespace ts {
     export function countWhere<T>(array: T[], predicate: (x: T) => boolean): number {
         let count = 0;
         if (array) {
-            for (let v of array) {
+            for (const v of array) {
                 if (predicate(v)) {
                     count++;
                 }
@@ -117,11 +127,11 @@ namespace ts {
         return count;
     }
 
-    export function filter<T>(array: T[], f: (x: T) => boolean): T[]{
+    export function filter<T>(array: T[], f: (x: T) => boolean): T[] {
         let result: T[];
         if (array) {
             result = [];
-            for (let item of array) {
+            for (const item of array) {
                 if (f(item)) {
                     result.push(item);
                 }
@@ -130,11 +140,11 @@ namespace ts {
         return result;
     }
 
-    export function map<T, U>(array: T[], f: (x: T) => U): U[]{
+    export function map<T, U>(array: T[], f: (x: T) => U): U[] {
         let result: U[];
         if (array) {
             result = [];
-            for (let v of array) {
+            for (const v of array) {
                 result.push(f(v));
             }
         }
@@ -148,11 +158,11 @@ namespace ts {
         return array1.concat(array2);
     }
 
-    export function deduplicate<T>(array: T[]): T[]{
+    export function deduplicate<T>(array: T[]): T[] {
         let result: T[];
         if (array) {
             result = [];
-            for (let item of array) {
+            for (const item of array) {
                 if (!contains(result, item)) {
                     result.push(item);
                 }
@@ -163,7 +173,7 @@ namespace ts {
 
     export function sum(array: any[], prop: string): number {
         let result = 0;
-        for (let v of array) {
+        for (const v of array) {
             result += v[prop];
         }
         return result;
@@ -171,7 +181,7 @@ namespace ts {
 
     export function addRange<T>(to: T[], from: T[]): void {
         if (to && from) {
-            for (let v of from) {
+            for (const v of from) {
                 to.push(v);
             }
         }
@@ -210,8 +220,8 @@ namespace ts {
         let high = array.length - 1;
 
         while (low <= high) {
-            let middle = low + ((high - low) >> 1);
-            let midValue = array[middle];
+            const middle = low + ((high - low) >> 1);
+            const midValue = array[middle];
 
             if (midValue === value) {
                 return middle;
@@ -260,7 +270,7 @@ namespace ts {
         return initial;
     }
 
-    let hasOwnProperty = Object.prototype.hasOwnProperty;
+    const hasOwnProperty = Object.prototype.hasOwnProperty;
 
     export function hasProperty<T>(map: Map<T>, key: string): boolean {
         return hasOwnProperty.call(map, key);
@@ -271,7 +281,7 @@ namespace ts {
     }
 
     export function isEmpty<T>(map: Map<T>) {
-        for (let id in map) {
+        for (const id in map) {
             if (hasProperty(map, id)) {
                 return false;
             }
@@ -280,19 +290,19 @@ namespace ts {
     }
 
     export function clone<T>(object: T): T {
-        let result: any = {};
-        for (let id in object) {
+        const result: any = {};
+        for (const id in object) {
             result[id] = (<any>object)[id];
         }
         return <T>result;
     }
 
-    export function extend<T1, T2>(first: Map<T1>, second: Map<T2>): Map<T1 & T2> {
-        let result: Map<T1 & T2> = {};
-        for (let id in first) {
+    export function extend<T1 extends Map<{}>, T2 extends Map<{}>>(first: T1 , second: T2): T1 & T2 {
+        const result: T1 & T2 = <any>{};
+        for (const id in first) {
             (result as any)[id] = first[id];
         }
-        for (let id in second) {
+        for (const id in second) {
             if (!hasProperty(result, id)) {
                 (result as any)[id] = second[id];
             }
@@ -302,7 +312,7 @@ namespace ts {
 
     export function forEachValue<T, U>(map: Map<T>, callback: (value: T) => U): U {
         let result: U;
-        for (let id in map) {
+        for (const id in map) {
             if (result = callback(map[id])) break;
         }
         return result;
@@ -310,7 +320,7 @@ namespace ts {
 
     export function forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U {
         let result: U;
-        for (let id in map) {
+        for (const id in map) {
             if (result = callback(id)) break;
         }
         return result;
@@ -321,7 +331,7 @@ namespace ts {
     }
 
     export function copyMap<T>(source: Map<T>, target: Map<T>): void {
-        for (let p in source) {
+        for (const p in source) {
             target[p] = source[p];
         }
     }
@@ -337,7 +347,7 @@ namespace ts {
      * index in the array will be the one associated with the produced key.
      */
     export function arrayToMap<T>(array: T[], makeKey: (value: T) => string): Map<T> {
-        let result: Map<T> = {};
+        const result: Map<T> = {};
 
         forEach(array, value => {
             result[makeKey(value)] = value;
@@ -365,15 +375,15 @@ namespace ts {
 
     export let localizedDiagnosticMessages: Map<string> = undefined;
 
-    export function getLocaleSpecificMessage(message: string) {
-        return localizedDiagnosticMessages && localizedDiagnosticMessages[message]
-            ? localizedDiagnosticMessages[message]
-            : message;
+    export function getLocaleSpecificMessage(message: DiagnosticMessage) {
+        return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key]
+            ? localizedDiagnosticMessages[message.key]
+            : message.message;
     }
 
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ...args: any[]): Diagnostic;
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage): Diagnostic {
-        let end = start + length;
+        const end = start + length;
 
         Debug.assert(start >= 0, "start must be non-negative, is " + start);
         Debug.assert(length >= 0, "length must be non-negative, is " + length);
@@ -383,7 +393,7 @@ namespace ts {
             Debug.assert(end <= file.text.length, `end must be the bounds of the file. ${ end } > ${ file.text.length }`);
         }
 
-        let text = getLocaleSpecificMessage(message.key);
+        let text = getLocaleSpecificMessage(message);
 
         if (arguments.length > 4) {
             text = formatStringFromArgs(text, arguments, 4);
@@ -402,7 +412,7 @@ namespace ts {
 
     export function createCompilerDiagnostic(message: DiagnosticMessage, ...args: any[]): Diagnostic;
     export function createCompilerDiagnostic(message: DiagnosticMessage): Diagnostic {
-        let text = getLocaleSpecificMessage(message.key);
+        let text = getLocaleSpecificMessage(message);
 
         if (arguments.length > 1) {
             text = formatStringFromArgs(text, arguments, 1);
@@ -421,7 +431,7 @@ namespace ts {
 
     export function chainDiagnosticMessages(details: DiagnosticMessageChain, message: DiagnosticMessage, ...args: any[]): DiagnosticMessageChain;
     export function chainDiagnosticMessages(details: DiagnosticMessageChain, message: DiagnosticMessage): DiagnosticMessageChain {
-        let text = getLocaleSpecificMessage(message.key);
+        let text = getLocaleSpecificMessage(message);
 
         if (arguments.length > 2) {
             text = formatStringFromArgs(text, arguments, 2);
@@ -437,8 +447,12 @@ namespace ts {
     }
 
     export function concatenateDiagnosticMessageChains(headChain: DiagnosticMessageChain, tailChain: DiagnosticMessageChain): DiagnosticMessageChain {
-        Debug.assert(!headChain.next);
-        headChain.next = tailChain;
+        let lastChain = headChain;
+        while (lastChain.next) {
+            lastChain = lastChain.next;
+        }
+
+        lastChain.next = tailChain;
         return headChain;
     }
 
@@ -465,10 +479,10 @@ namespace ts {
     function compareMessageText(text1: string | DiagnosticMessageChain, text2: string | DiagnosticMessageChain): Comparison {
         while (text1 && text2) {
             // We still have both chains.
-            let string1 = typeof text1 === "string" ? text1 : text1.messageText;
-            let string2 = typeof text2 === "string" ? text2 : text2.messageText;
+            const string1 = typeof text1 === "string" ? text1 : text1.messageText;
+            const string2 = typeof text2 === "string" ? text2 : text2.messageText;
 
-            let res = compareValues(string1, string2);
+            const res = compareValues(string1, string2);
             if (res) {
                 return res;
             }
@@ -486,7 +500,7 @@ namespace ts {
         return text1 ? Comparison.GreaterThan : Comparison.LessThan;
     }
 
-    export function sortAndDeduplicateDiagnostics(diagnostics: Diagnostic[]): Diagnostic[]{
+    export function sortAndDeduplicateDiagnostics(diagnostics: Diagnostic[]): Diagnostic[] {
         return deduplicateSortedDiagnostics(diagnostics.sort(compareDiagnostics));
     }
 
@@ -495,11 +509,11 @@ namespace ts {
             return diagnostics;
         }
 
-        let newDiagnostics = [diagnostics[0]];
+        const newDiagnostics = [diagnostics[0]];
         let previousDiagnostic = diagnostics[0];
         for (let i = 1; i < diagnostics.length; i++) {
-            let currentDiagnostic = diagnostics[i];
-            let isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === Comparison.EqualTo;
+            const currentDiagnostic = diagnostics[i];
+            const isDupe = compareDiagnostics(currentDiagnostic, previousDiagnostic) === Comparison.EqualTo;
             if (!isDupe) {
                 newDiagnostics.push(currentDiagnostic);
                 previousDiagnostic = currentDiagnostic;
@@ -517,9 +531,9 @@ namespace ts {
     export function getRootLength(path: string): number {
         if (path.charCodeAt(0) === CharacterCodes.slash) {
             if (path.charCodeAt(1) !== CharacterCodes.slash) return 1;
-            let p1 = path.indexOf("/", 2);
+            const p1 = path.indexOf("/", 2);
             if (p1 < 0) return 2;
-            let p2 = path.indexOf("/", p1 + 1);
+            const p2 = path.indexOf("/", p1 + 1);
             if (p2 < 0) return p1 + 1;
             return p2 + 1;
         }
@@ -535,7 +549,7 @@ namespace ts {
         if (path.lastIndexOf("file:///", 0) === 0) {
             return "file:///".length;
         }
-        let idx = path.indexOf("://");
+        const idx = path.indexOf("://");
         if (idx !== -1) {
             return idx + "://".length;
         }
@@ -544,9 +558,9 @@ namespace ts {
 
     export let directorySeparator = "/";
     function getNormalizedParts(normalizedSlashedPath: string, rootLength: number) {
-        let parts = normalizedSlashedPath.substr(rootLength).split(directorySeparator);
-        let normalized: string[] = [];
-        for (let part of parts) {
+        const parts = normalizedSlashedPath.substr(rootLength).split(directorySeparator);
+        const normalized: string[] = [];
+        for (const part of parts) {
             if (part !== ".") {
                 if (part === ".." && normalized.length > 0 && lastOrUndefined(normalized) !== "..") {
                     normalized.pop();
@@ -566,8 +580,8 @@ namespace ts {
 
     export function normalizePath(path: string): string {
         path = normalizeSlashes(path);
-        let rootLength = getRootLength(path);
-        let normalized = getNormalizedParts(path, rootLength);
+        const rootLength = getRootLength(path);
+        const normalized = getNormalizedParts(path, rootLength);
         return path.substr(0, rootLength) + normalized.join(directorySeparator);
     }
 
@@ -584,7 +598,7 @@ namespace ts {
     }
 
     function normalizedPathComponents(path: string, rootLength: number) {
-        let normalizedParts = getNormalizedParts(path, rootLength);
+        const normalizedParts = getNormalizedParts(path, rootLength);
         return [path.substr(0, rootLength)].concat(normalizedParts);
     }
 
@@ -615,7 +629,7 @@ namespace ts {
         // In this example the root is:  http://www.website.com/
         // normalized path components should be ["http://www.website.com/", "folder1", "folder2"]
 
-        let urlLength = url.length;
+        const urlLength = url.length;
         // Initial root length is http:// part
         let rootLength = url.indexOf("://") + "://".length;
         while (rootLength < urlLength) {
@@ -636,7 +650,7 @@ namespace ts {
         }
 
         // Find the index of "/" after website.com so the root can be http://www.website.com/ (from existing http://)
-        let indexOfNextSlash = url.indexOf(directorySeparator, rootLength);
+        const indexOfNextSlash = url.indexOf(directorySeparator, rootLength);
         if (indexOfNextSlash !== -1) {
             // Found the "/" after the website.com so the root is length of http://www.website.com/
             // and get components afetr the root normally like any other folder components
@@ -662,8 +676,8 @@ namespace ts {
     }
 
     export function getRelativePathToDirectoryOrUrl(directoryPathOrUrl: string, relativeOrAbsolutePath: string, currentDirectory: string, getCanonicalFileName: (fileName: string) => string, isAbsolutePathAnUrl: boolean) {
-        let pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
-        let directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
+        const pathComponents = getNormalizedPathOrUrlComponents(relativeOrAbsolutePath, currentDirectory);
+        const directoryComponents = getNormalizedPathOrUrlComponents(directoryPathOrUrl, currentDirectory);
         if (directoryComponents.length > 1 && lastOrUndefined(directoryComponents) === "") {
             // If the directory path given was of type test/cases/ then we really need components of directory to be only till its name
             // that is  ["test", "cases", ""] needs to be actually ["test", "cases"]
@@ -680,7 +694,7 @@ namespace ts {
         // Get the relative path
         if (joinStartIndex) {
             let relativePath = "";
-            let relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length);
+            const relativePathComponents = pathComponents.slice(joinStartIndex, pathComponents.length);
             for (; joinStartIndex < directoryComponents.length; joinStartIndex++) {
                 if (directoryComponents[joinStartIndex] !== "") {
                     relativePath = relativePath + ".." + directorySeparator;
@@ -700,7 +714,10 @@ namespace ts {
     }
 
     export function getBaseFileName(path: string) {
-        let i = path.lastIndexOf(directorySeparator);
+        if (path === undefined) {
+            return undefined;
+        }
+        const i = path.lastIndexOf(directorySeparator);
         return i < 0 ? path : path.substring(i + 1);
     }
 
@@ -713,19 +730,36 @@ namespace ts {
     }
 
     export function fileExtensionIs(path: string, extension: string): boolean {
-        let pathLen = path.length;
-        let extLen = extension.length;
+        const pathLen = path.length;
+        const extLen = extension.length;
         return pathLen > extLen && path.substr(pathLen - extLen, extLen) === extension;
     }
 
     /**
      *  List of supported extensions in order of file resolution precedence.
      */
-    export const supportedExtensions = [".ts", ".tsx", ".d.ts"];
+    export const supportedTypeScriptExtensions = [".ts", ".tsx", ".d.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 isSupportedSourceFileName(fileName: string, compilerOptions?: CompilerOptions) {
+        if (!fileName) { return false; }
+
+        for (const extension of getSupportedExtensions(compilerOptions)) {
+            if (fileExtensionIs(fileName, extension)) {
+                return true;
+            }
+        }
+        return false;
+    }
 
     const extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"];
     export function removeFileExtension(path: string): string {
-        for (let ext of extensionsToRemove) {
+        for (const ext of extensionsToRemove) {
             if (fileExtensionIs(path, ext)) {
                 return path.substr(0, path.length - ext.length);
             }
@@ -733,9 +767,9 @@ namespace ts {
         return path;
     }
 
-    let backslashOrDoubleQuote = /[\"\\]/g;
-    let escapedCharsRegExp = /[\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
-    let escapedCharsMap: Map<string> = {
+    const backslashOrDoubleQuote = /[\"\\]/g;
+    const escapedCharsRegExp = /[\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
+    const escapedCharsMap: Map<string> = {
         "\0": "\\0",
         "\t": "\\t",
         "\v": "\\v",
@@ -751,7 +785,8 @@ namespace ts {
     };
 
     export interface ObjectAllocator {
-        getNodeConstructor(kind: SyntaxKind): new () => Node;
+        getNodeConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => Node;
+        getSourceFileConstructor(): new (kind: SyntaxKind, pos?: number, end?: number) => SourceFile;
         getSymbolConstructor(): new (flags: SymbolFlags, name: string) => Symbol;
         getTypeConstructor(): new (checker: TypeChecker, flags: TypeFlags) => Type;
         getSignatureConstructor(): new (checker: TypeChecker) => Signature;
@@ -770,19 +805,17 @@ namespace ts {
     function Signature(checker: TypeChecker) {
     }
 
+    function Node(kind: SyntaxKind, pos: number, end: number) {
+        this.kind = kind;
+        this.pos = pos;
+        this.end = end;
+        this.flags = NodeFlags.None;
+        this.parent = undefined;
+    }
+
     export let objectAllocator: ObjectAllocator = {
-        getNodeConstructor: kind => {
-            function Node() {
-            }
-            Node.prototype = {
-                kind: kind,
-                pos: -1,
-                end: -1,
-                flags: 0,
-                parent: undefined,
-            };
-            return <any>Node;
-        },
+        getNodeConstructor: () => <any>Node,
+        getSourceFileConstructor: () => <any>Node,
         getSymbolConstructor: () => <any>Symbol,
         getTypeConstructor: () => <any>Type,
         getSignatureConstructor: () => <any>Signature
@@ -795,8 +828,8 @@ namespace ts {
         VeryAggressive = 3,
     }
 
-    export module Debug {
-        let currentAssertionLevel = AssertionLevel.None;
+    export namespace Debug {
+        const currentAssertionLevel = AssertionLevel.None;
 
         export function shouldAssert(level: AssertionLevel): boolean {
             return currentAssertionLevel >= level;
@@ -808,13 +841,23 @@ namespace ts {
                 if (verboseDebugInfo) {
                     verboseDebugString = "\r\nVerbose Debug Information: " + verboseDebugInfo();
                 }
-
+                debugger;
                 throw new Error("Debug Failure. False expression: " + (message || "") + verboseDebugString);
             }
         }
 
         export function fail(message?: string): void {
-            Debug.assert(false, message);
+            Debug.assert(/*expression*/ false, message);
         }
     }
+
+    export function copyListRemovingItem<T>(item: T, list: T[]) {
+        const copiedList: T[] = [];
+        for (const e of list) {
+            if (e !== item) {
+                copiedList.push(e);
+            }
+        }
+        return copiedList;
+    }
 }

src/compiler/declarationEmitter.ts

@@ -31,29 +31,38 @@ namespace ts {
     }
 
     export function getDeclarationDiagnostics(host: EmitHost, resolver: EmitResolver, targetSourceFile: SourceFile): Diagnostic[] {
-        let diagnostics: Diagnostic[] = [];
-        let jsFilePath = getOwnEmitOutputFilePath(targetSourceFile, host, ".js");
-        emitDeclarations(host, resolver, diagnostics, jsFilePath, targetSourceFile);
-        return diagnostics;
+        const declarationDiagnostics = createDiagnosticCollection();
+        forEachExpectedEmitFile(host, getDeclarationDiagnosticsFromFile, targetSourceFile);
+        return declarationDiagnostics.getDiagnostics(targetSourceFile.fileName);
+
+        function getDeclarationDiagnosticsFromFile({ declarationFilePath }, sources: SourceFile[], isBundledEmit: boolean) {
+            emitDeclarations(host, resolver, declarationDiagnostics, declarationFilePath, sources, isBundledEmit);
+        }
     }
 
-    function emitDeclarations(host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[], jsFilePath: string, root?: SourceFile): DeclarationEmit {
-        let newLine = host.getNewLine();
-        let compilerOptions = host.getCompilerOptions();
+    function emitDeclarations(host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection, declarationFilePath: string,
+        sourceFiles: SourceFile[], isBundledEmit: boolean): DeclarationEmit {
+        const newLine = host.getNewLine();
+        const compilerOptions = host.getCompilerOptions();
 
         let write: (s: string) => void;
         let writeLine: () => void;
         let increaseIndent: () => void;
         let decreaseIndent: () => void;
-        let writeTextOfNode: (sourceFile: SourceFile, node: Node) => void;
+        let writeTextOfNode: (text: string, node: Node) => void;
 
         let writer = createAndSetNewTextWriterWithSymbolWriter();
 
         let enclosingDeclaration: Node;
-        let currentSourceFile: SourceFile;
+        let currentText: string;
+        let currentLineMap: number[];
+        let currentIdentifiers: Map<string>;
+        let isCurrentFileExternalModule: boolean;
         let reportedDeclarationError = false;
-        let emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
-        let emit = compilerOptions.stripInternal ? stripInternal : emitNode;
+        let errorNameNode: DeclarationName;
+        const emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments;
+        const emit = compilerOptions.stripInternal ? stripInternal : emitNode;
+        let noDeclare: boolean;
 
         let moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
         let asynchronousSubModuleDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[];
@@ -63,84 +72,90 @@ namespace ts {
         // and we could be collecting these paths from multiple files into single one with --out option
         let referencePathsOutput = "";
 
-        if (root) {
-            // Emitting just a single file, so emit references in this file only
+        // Emit references corresponding to each file
+        const emittedReferencedFiles: SourceFile[] = [];
+        let addedGlobalFileReference = false;
+        let allSourcesModuleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[] = [];
+        forEach(sourceFiles, sourceFile => {
+            // Dont emit for javascript file
+            if (isSourceFileJavaScript(sourceFile)) {
+                return;
+            }
+
+            // Check what references need to be added
             if (!compilerOptions.noResolve) {
-                let addedGlobalFileReference = false;
-                forEach(root.referencedFiles, fileReference => {
-                    let referencedFile = tryResolveScriptReference(host, root, fileReference);
+                forEach(sourceFile.referencedFiles, fileReference => {
+                    const referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
 
-                    // All the references that are not going to be part of same file
-                    if (referencedFile && ((referencedFile.flags & NodeFlags.DeclarationFile) || // This is a declare file reference
-                        shouldEmitToOwnFile(referencedFile, compilerOptions) || // This is referenced file is emitting its own js file
-                        !addedGlobalFileReference)) { // Or the global out file corresponding to this reference was not added
-
-                        writeReferencePath(referencedFile);
-                        if (!isExternalModuleOrDeclarationFile(referencedFile)) {
+                    // Emit reference in dts, if the file reference was not already emitted
+                    if (referencedFile && !contains(emittedReferencedFiles, referencedFile)) {
+                        // Add a reference to generated dts file,
+                        // global file reference is added only 
+                        //  - if it is not bundled emit (because otherwise it would be self reference)
+                        //  - and it is not already added
+                        if (writeReferencePath(referencedFile, !isBundledEmit && !addedGlobalFileReference)) {
                             addedGlobalFileReference = true;
                         }
+                        emittedReferencedFiles.push(referencedFile);
                     }
                 });
             }
 
-            emitSourceFile(root);
+            if (!isBundledEmit || !isExternalModule(sourceFile)) {
+                noDeclare = false;
+                emitSourceFile(sourceFile);
+            }
+            else if (isExternalModule(sourceFile)) {
+                noDeclare = true;
+                write(`declare module "${getResolvedExternalModuleName(host, sourceFile)}" {`);
+                writeLine();
+                increaseIndent();
+                emitSourceFile(sourceFile);
+                decreaseIndent();
+                write("}");
+                writeLine();
+            }
 
             // create asynchronous output for the importDeclarations
             if (moduleElementDeclarationEmitInfo.length) {
-                let oldWriter = writer;
+                const oldWriter = writer;
                 forEach(moduleElementDeclarationEmitInfo, aliasEmitInfo => {
-                    if (aliasEmitInfo.isVisible) {
+                    if (aliasEmitInfo.isVisible && !aliasEmitInfo.asynchronousOutput) {
                         Debug.assert(aliasEmitInfo.node.kind === SyntaxKind.ImportDeclaration);
                         createAndSetNewTextWriterWithSymbolWriter();
-                        Debug.assert(aliasEmitInfo.indent === 0);
+                        Debug.assert(aliasEmitInfo.indent === 0 || (aliasEmitInfo.indent === 1 && isBundledEmit));
+                        for (let i = 0; i < aliasEmitInfo.indent; i++) {
+                            increaseIndent();
+                        }
                         writeImportDeclaration(<ImportDeclaration>aliasEmitInfo.node);
                         aliasEmitInfo.asynchronousOutput = writer.getText();
+                        for (let i = 0; i < aliasEmitInfo.indent; i++) {
+                            decreaseIndent();
+                        }
                     }
                 });
                 setWriter(oldWriter);
+
+                allSourcesModuleElementDeclarationEmitInfo = allSourcesModuleElementDeclarationEmitInfo.concat(moduleElementDeclarationEmitInfo);
+                moduleElementDeclarationEmitInfo = [];
             }
-        }
-        else {
-            // Emit references corresponding to this file
-            let emittedReferencedFiles: SourceFile[] = [];
-            forEach(host.getSourceFiles(), sourceFile => {
-                if (!isExternalModuleOrDeclarationFile(sourceFile)) {
-                    // Check what references need to be added
-                    if (!compilerOptions.noResolve) {
-                        forEach(sourceFile.referencedFiles, fileReference => {
-                            let referencedFile = tryResolveScriptReference(host, sourceFile, fileReference);
-
-                            // If the reference file is a declaration file or an external module, emit that reference
-                            if (referencedFile && (isExternalModuleOrDeclarationFile(referencedFile) &&
-                                !contains(emittedReferencedFiles, referencedFile))) { // If the file reference was not already emitted
-
-                                writeReferencePath(referencedFile);
-                                emittedReferencedFiles.push(referencedFile);
-                            }
-                        });
-                    }
-
-                    emitSourceFile(sourceFile);
-                }
-            });
-        }
+        });
 
         return {
             reportedDeclarationError,
-            moduleElementDeclarationEmitInfo,
+            moduleElementDeclarationEmitInfo: allSourcesModuleElementDeclarationEmitInfo,
             synchronousDeclarationOutput: writer.getText(),
             referencePathsOutput,
         };
 
         function hasInternalAnnotation(range: CommentRange) {
-            let text = currentSourceFile.text;
-            let comment = text.substring(range.pos, range.end);
+            const comment = currentText.substring(range.pos, range.end);
             return comment.indexOf("@internal") >= 0;
         }
 
         function stripInternal(node: Node) {
             if (node) {
-                let leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+                const leadingCommentRanges = getLeadingCommentRanges(currentText, node.pos);
                 if (forEach(leadingCommentRanges, hasInternalAnnotation)) {
                     return;
                 }
@@ -150,8 +165,9 @@ namespace ts {
         }
 
         function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter {
-            let writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
+            const writer = <EmitTextWriterWithSymbolWriter>createTextWriter(newLine);
             writer.trackSymbol = trackSymbol;
+            writer.reportInaccessibleThisError = reportInaccessibleThisError;
             writer.writeKeyword = writer.write;
             writer.writeOperator = writer.write;
             writer.writePunctuation = writer.write;
@@ -173,14 +189,16 @@ namespace ts {
         }
 
         function writeAsynchronousModuleElements(nodes: Node[]) {
-            let oldWriter = writer;
+            const oldWriter = writer;
             forEach(nodes, declaration => {
                 let nodeToCheck: Node;
                 if (declaration.kind === SyntaxKind.VariableDeclaration) {
                     nodeToCheck = declaration.parent.parent;
-                } else if (declaration.kind === SyntaxKind.NamedImports || declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ImportClause) {
+                }
+                else if (declaration.kind === SyntaxKind.NamedImports || declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ImportClause) {
                     Debug.fail("We should be getting ImportDeclaration instead to write");
-                } else {
+                }
+                else {
                     nodeToCheck = declaration;
                 }
 
@@ -234,17 +252,17 @@ namespace ts {
             else {
                 // Report error
                 reportedDeclarationError = true;
-                let errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult);
+                const errorInfo = writer.getSymbolAccessibilityDiagnostic(symbolAccesibilityResult);
                 if (errorInfo) {
                     if (errorInfo.typeName) {
-                        diagnostics.push(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
+                        emitterDiagnostics.add(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
                             errorInfo.diagnosticMessage,
-                            getSourceTextOfNodeFromSourceFile(currentSourceFile, errorInfo.typeName),
+                            getTextOfNodeFromSourceText(currentText, errorInfo.typeName),
                             symbolAccesibilityResult.errorSymbolName,
                             symbolAccesibilityResult.errorModuleName));
                     }
                     else {
-                        diagnostics.push(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
+                        emitterDiagnostics.add(createDiagnosticForNode(symbolAccesibilityResult.errorNode || errorInfo.errorNode,
                             errorInfo.diagnosticMessage,
                             symbolAccesibilityResult.errorSymbolName,
                             symbolAccesibilityResult.errorModuleName));
@@ -257,6 +275,14 @@ namespace ts {
             handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning));
         }
 
+        function reportInaccessibleThisError() {
+            if (errorNameNode) {
+                reportedDeclarationError = true;
+                emitterDiagnostics.add(createDiagnosticForNode(errorNameNode, Diagnostics.The_inferred_type_of_0_references_an_inaccessible_this_type_A_type_annotation_is_necessary,
+                    declarationNameToString(errorNameNode)));
+            }
+        }
+
         function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) {
             writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic;
             write(": ");
@@ -265,7 +291,9 @@ namespace ts {
                 emitType(type);
             }
             else {
+                errorNameNode = declaration.name;
                 resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                errorNameNode = undefined;
             }
         }
 
@@ -277,19 +305,21 @@ namespace ts {
                 emitType(signature.type);
             }
             else {
+                errorNameNode = signature.name;
                 resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer);
+                errorNameNode = undefined;
             }
         }
 
         function emitLines(nodes: Node[]) {
-            for (let node of nodes) {
+            for (const node of nodes) {
                 emit(node);
             }
         }
 
         function emitSeparatedList(nodes: Node[], separator: string, eachNodeEmitFn: (node: Node) => void, canEmitFn?: (node: Node) => boolean) {
             let currentWriterPos = writer.getTextPos();
-            for (let node of nodes) {
+            for (const node of nodes) {
                 if (!canEmitFn || canEmitFn(node)) {
                     if (currentWriterPos !== writer.getTextPos()) {
                         write(separator);
@@ -306,10 +336,10 @@ namespace ts {
 
         function writeJsDocComments(declaration: Node) {
             if (declaration) {
-                let jsDocComments = getJsDocComments(declaration, currentSourceFile);
-                emitNewLineBeforeLeadingComments(currentSourceFile, writer, declaration, jsDocComments);
+                const jsDocComments = getJsDocCommentsFromText(declaration, currentText);
+                emitNewLineBeforeLeadingComments(currentLineMap, writer, declaration, jsDocComments);
                 // jsDoc comments are emitted at /*leading comment1 */space/*leading comment*/space
-                emitComments(currentSourceFile, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
+                emitComments(currentText, currentLineMap, writer, jsDocComments, /*trailingSeparator*/ true, newLine, writeCommentRange);
             }
         }
 
@@ -326,8 +356,9 @@ namespace ts {
                 case SyntaxKind.BooleanKeyword:
                 case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.VoidKeyword:
+                case SyntaxKind.ThisType:
                 case SyntaxKind.StringLiteral:
-                    return writeTextOfNode(currentSourceFile, type);
+                    return writeTextOfNode(currentText, type);
                 case SyntaxKind.ExpressionWithTypeArguments:
                     return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>type);
                 case SyntaxKind.TypeReference:
@@ -359,19 +390,19 @@ namespace ts {
 
             function writeEntityName(entityName: EntityName | Expression) {
                 if (entityName.kind === SyntaxKind.Identifier) {
-                    writeTextOfNode(currentSourceFile, entityName);
+                    writeTextOfNode(currentText, entityName);
                 }
                 else {
-                    let left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
-                    let right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
+                    const left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
+                    const right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
                     writeEntityName(left);
                     write(".");
-                    writeTextOfNode(currentSourceFile, right);
+                    writeTextOfNode(currentText, right);
                 }
             }
 
             function emitEntityName(entityName: EntityName | PropertyAccessExpression) {
-                let visibilityResult = resolver.isEntityNameVisible(entityName,
+                const visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
                     entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ? entityName.parent : enclosingDeclaration);
 
@@ -401,7 +432,7 @@ namespace ts {
             }
 
             function emitTypePredicate(type: TypePredicateNode) {
-                writeTextOfNode(currentSourceFile, type.parameterName);
+                writeTextOfNode(currentText, type.parameterName);
                 write(" is ");
                 emitType(type.type);
             }
@@ -450,8 +481,12 @@ namespace ts {
         }
 
         function emitSourceFile(node: SourceFile) {
-            currentSourceFile = node;
+            currentText = node.text;
+            currentLineMap = getLineStarts(node);
+            currentIdentifiers = node.identifiers;
+            isCurrentFileExternalModule = isExternalModule(node);
             enclosingDeclaration = node;
+            emitDetachedComments(currentText, currentLineMap, writer, writeCommentRange, node, newLine, true /* remove comments */);
             emitLines(node.statements);
         }
 
@@ -460,14 +495,14 @@ namespace ts {
         // Note that export default is only allowed at most once in a module, so we
         // do not need to keep track of created temp names.
         function getExportDefaultTempVariableName(): string {
-            let baseName = "_default";
-            if (!hasProperty(currentSourceFile.identifiers, baseName)) {
+            const baseName = "_default";
+            if (!hasProperty(currentIdentifiers, baseName)) {
                 return baseName;
             }
             let count = 0;
             while (true) {
-                let name = baseName + "_" + (++count);
-                if (!hasProperty(currentSourceFile.identifiers, name)) {
+                const name = baseName + "_" + (++count);
+                if (!hasProperty(currentIdentifiers, name)) {
                     return name;
                 }
             }
@@ -476,11 +511,11 @@ namespace ts {
         function emitExportAssignment(node: ExportAssignment) {
             if (node.expression.kind === SyntaxKind.Identifier) {
                 write(node.isExportEquals ? "export = " : "export default ");
-                writeTextOfNode(currentSourceFile, node.expression);
+                writeTextOfNode(currentText, node.expression);
             }
             else {
                 // Expression
-                let tempVarName = getExportDefaultTempVariableName();
+                const tempVarName = getExportDefaultTempVariableName();
                 write("declare var ");
                 write(tempVarName);
                 write(": ");
@@ -496,7 +531,7 @@ namespace ts {
 
             // Make all the declarations visible for the export name
             if (node.expression.kind === SyntaxKind.Identifier) {
-                let nodes = resolver.collectLinkedAliases(<Identifier>node.expression);
+                const nodes = resolver.collectLinkedAliases(<Identifier>node.expression);
 
                 // write each of these declarations asynchronously
                 writeAsynchronousModuleElements(nodes);
@@ -520,7 +555,7 @@ namespace ts {
             }
             // Import equals declaration in internal module can become visible as part of any emit so lets make sure we add these irrespective
             else if (node.kind === SyntaxKind.ImportEqualsDeclaration ||
-                (node.parent.kind === SyntaxKind.SourceFile && isExternalModule(currentSourceFile))) {
+                (node.parent.kind === SyntaxKind.SourceFile && isCurrentFileExternalModule)) {
                 let isVisible: boolean;
                 if (asynchronousSubModuleDeclarationEmitInfo && node.parent.kind !== SyntaxKind.SourceFile) {
                     // Import declaration of another module that is visited async so lets put it in right spot
@@ -533,7 +568,7 @@ namespace ts {
                 }
                 else {
                     if (node.kind === SyntaxKind.ImportDeclaration) {
-                        let importDeclaration = <ImportDeclaration>node;
+                        const importDeclaration = <ImportDeclaration>node;
                         if (importDeclaration.importClause) {
                             isVisible = (importDeclaration.importClause.name && resolver.isDeclarationVisible(importDeclaration.importClause)) ||
                             isVisibleNamedBinding(importDeclaration.importClause.namedBindings);
@@ -576,7 +611,7 @@ namespace ts {
 
         function emitModuleElementDeclarationFlags(node: Node) {
             // If the node is parented in the current source file we need to emit export declare or just export
-            if (node.parent === currentSourceFile) {
+            if (node.parent.kind === SyntaxKind.SourceFile) {
                 // If the node is exported
                 if (node.flags & NodeFlags.Export) {
                     write("export ");
@@ -585,7 +620,7 @@ namespace ts {
                 if (node.flags & NodeFlags.Default) {
                     write("default ");
                 }
-                else if (node.kind !== SyntaxKind.InterfaceDeclaration) {
+                else if (node.kind !== SyntaxKind.InterfaceDeclaration && !noDeclare) {
                     write("declare ");
                 }
             }
@@ -615,7 +650,7 @@ namespace ts {
                 write("export ");
             }
             write("import ");
-            writeTextOfNode(currentSourceFile, node.name);
+            writeTextOfNode(currentText, node.name);
             write(" = ");
             if (isInternalModuleImportEqualsDeclaration(node)) {
                 emitTypeWithNewGetSymbolAccessibilityDiagnostic(<EntityName>node.moduleReference, getImportEntityNameVisibilityError);
@@ -623,7 +658,7 @@ namespace ts {
             }
             else {
                 write("require(");
-                writeTextOfNode(currentSourceFile, getExternalModuleImportEqualsDeclarationExpression(node));
+                writeTextOfNode(currentText, getExternalModuleImportEqualsDeclarationExpression(node));
                 write(");");
             }
             writer.writeLine();
@@ -659,9 +694,9 @@ namespace ts {
             }
             write("import ");
             if (node.importClause) {
-                let currentWriterPos = writer.getTextPos();
+                const currentWriterPos = writer.getTextPos();
                 if (node.importClause.name && resolver.isDeclarationVisible(node.importClause)) {
-                    writeTextOfNode(currentSourceFile, node.importClause.name);
+                    writeTextOfNode(currentText, node.importClause.name);
                 }
                 if (node.importClause.namedBindings && isVisibleNamedBinding(node.importClause.namedBindings)) {
                     if (currentWriterPos !== writer.getTextPos()) {
@@ -670,7 +705,7 @@ namespace ts {
                     }
                     if (node.importClause.namedBindings.kind === SyntaxKind.NamespaceImport) {
                         write("* as ");
-                        writeTextOfNode(currentSourceFile, (<NamespaceImport>node.importClause.namedBindings).name);
+                        writeTextOfNode(currentText, (<NamespaceImport>node.importClause.namedBindings).name);
                     }
                     else {
                         write("{ ");
@@ -680,24 +715,38 @@ namespace ts {
                 }
                 write(" from ");
             }
-            writeTextOfNode(currentSourceFile, node.moduleSpecifier);
+            emitExternalModuleSpecifier(node.moduleSpecifier);
             write(";");
             writer.writeLine();
         }
 
+        function emitExternalModuleSpecifier(moduleSpecifier: Expression) {
+            if (moduleSpecifier.kind === SyntaxKind.StringLiteral && isBundledEmit) {
+                const moduleName = getExternalModuleNameFromDeclaration(host, resolver, moduleSpecifier.parent as (ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration));
+                if (moduleName) {
+                    write("\"");
+                    write(moduleName);
+                    write("\"");
+                    return;
+                }
+            }
+
+            writeTextOfNode(currentText, moduleSpecifier);
+        }
+
         function emitImportOrExportSpecifier(node: ImportOrExportSpecifier) {
             if (node.propertyName) {
-                writeTextOfNode(currentSourceFile, node.propertyName);
+                writeTextOfNode(currentText, node.propertyName);
                 write(" as ");
             }
-            writeTextOfNode(currentSourceFile, node.name);
+            writeTextOfNode(currentText, node.name);
         }
 
         function emitExportSpecifier(node: ExportSpecifier) {
             emitImportOrExportSpecifier(node);
 
             // Make all the declarations visible for the export name
-            let nodes = resolver.collectLinkedAliases(node.propertyName || node.name);
+            const nodes = resolver.collectLinkedAliases(node.propertyName || node.name);
 
             // write each of these declarations asynchronously
             writeAsynchronousModuleElements(nodes);
@@ -716,7 +765,7 @@ namespace ts {
             }
             if (node.moduleSpecifier) {
                 write(" from ");
-                writeTextOfNode(currentSourceFile, node.moduleSpecifier);
+                emitExternalModuleSpecifier(node.moduleSpecifier);
             }
             write(";");
             writer.writeLine();
@@ -731,13 +780,13 @@ namespace ts {
             else {
                 write("module ");
             }
-            writeTextOfNode(currentSourceFile, node.name);
+            writeTextOfNode(currentText, node.name);
             while (node.body.kind !== SyntaxKind.ModuleBlock) {
                 node = <ModuleDeclaration>node.body;
                 write(".");
-                writeTextOfNode(currentSourceFile, node.name);
+                writeTextOfNode(currentText, node.name);
             }
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             write(" {");
             writeLine();
@@ -750,12 +799,12 @@ namespace ts {
         }
 
         function writeTypeAliasDeclaration(node: TypeAliasDeclaration) {
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             write("type ");
-            writeTextOfNode(currentSourceFile, node.name);
+            writeTextOfNode(currentText, node.name);
             emitTypeParameters(node.typeParameters);
             write(" = ");
             emitTypeWithNewGetSymbolAccessibilityDiagnostic(node.type, getTypeAliasDeclarationVisibilityError);
@@ -779,7 +828,7 @@ namespace ts {
                 write("const ");
             }
             write("enum ");
-            writeTextOfNode(currentSourceFile, node.name);
+            writeTextOfNode(currentText, node.name);
             write(" {");
             writeLine();
             increaseIndent();
@@ -791,8 +840,8 @@ namespace ts {
 
         function emitEnumMemberDeclaration(node: EnumMember) {
             emitJsDocComments(node);
-            writeTextOfNode(currentSourceFile, node.name);
-            let enumMemberValue = resolver.getConstantValue(node);
+            writeTextOfNode(currentText, node.name);
+            const enumMemberValue = resolver.getConstantValue(node);
             if (enumMemberValue !== undefined) {
                 write(" = ");
                 write(enumMemberValue.toString());
@@ -810,7 +859,7 @@ namespace ts {
                 increaseIndent();
                 emitJsDocComments(node);
                 decreaseIndent();
-                writeTextOfNode(currentSourceFile, node.name);
+                writeTextOfNode(currentText, node.name);
                 // If there is constraint present and this is not a type parameter of the private method emit the constraint
                 if (node.constraint && !isPrivateMethodTypeParameter(node)) {
                     write(" extends ");
@@ -941,11 +990,11 @@ namespace ts {
             }
 
             write("class ");
-            writeTextOfNode(currentSourceFile, node.name);
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            writeTextOfNode(currentText, node.name);
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitTypeParameters(node.typeParameters);
-            let baseTypeNode = getClassExtendsHeritageClauseElement(node);
+            const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
                 emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
             }
@@ -965,8 +1014,8 @@ namespace ts {
             emitJsDocComments(node);
             emitModuleElementDeclarationFlags(node);
             write("interface ");
-            writeTextOfNode(currentSourceFile, node.name);
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            writeTextOfNode(currentText, node.name);
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
             emitTypeParameters(node.typeParameters);
             emitHeritageClause(getInterfaceBaseTypeNodes(node), /*isImplementsList*/ false);
@@ -1003,7 +1052,7 @@ namespace ts {
                     // If this node is a computed name, it can only be a symbol, because we've already skipped
                     // it if it's not a well known symbol. In that case, the text of the name will be exactly
                     // what we want, namely the name expression enclosed in brackets.
-                    writeTextOfNode(currentSourceFile, node.name);
+                    writeTextOfNode(currentText, node.name);
                     // If optional property emit ?
                     if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
                         write("?");
@@ -1052,7 +1101,7 @@ namespace ts {
             }
 
             function getVariableDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                const diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                 return diagnosticMessage !== undefined ? {
                     diagnosticMessage,
                     errorNode: node,
@@ -1066,9 +1115,9 @@ namespace ts {
                 // For example:
                 //      original: var [, c,,] = [ 2,3,4]
                 //      emitted: declare var c: number; // instead of declare var c:number, ;
-                let elements: Node[] = [];
-                for (let element of bindingPattern.elements) {
-                    if (element.kind !== SyntaxKind.OmittedExpression){
+                const elements: Node[] = [];
+                for (const element of bindingPattern.elements) {
+                    if (element.kind !== SyntaxKind.OmittedExpression) {
                         elements.push(element);
                     }
                 }
@@ -1077,7 +1126,7 @@ namespace ts {
 
             function emitBindingElement(bindingElement: BindingElement) {
                 function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                    const diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                     return diagnosticMessage !== undefined ? {
                         diagnosticMessage,
                         errorNode: bindingElement,
@@ -1090,7 +1139,7 @@ namespace ts {
                         emitBindingPattern(<BindingPattern>bindingElement.name);
                     }
                     else {
-                        writeTextOfNode(currentSourceFile, bindingElement.name);
+                        writeTextOfNode(currentText, bindingElement.name);
                         writeTypeOfDeclaration(bindingElement, /*type*/ undefined, getBindingElementTypeVisibilityError);
                     }
                 }
@@ -1133,20 +1182,20 @@ namespace ts {
                 return;
             }
 
-            let accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
+            const accessors = getAllAccessorDeclarations((<ClassDeclaration>node.parent).members, node);
             let accessorWithTypeAnnotation: AccessorDeclaration;
 
             if (node === accessors.firstAccessor) {
                 emitJsDocComments(accessors.getAccessor);
                 emitJsDocComments(accessors.setAccessor);
                 emitClassMemberDeclarationFlags(node);
-                writeTextOfNode(currentSourceFile, node.name);
+                writeTextOfNode(currentText, node.name);
                 if (!(node.flags & NodeFlags.Private)) {
                     accessorWithTypeAnnotation = node;
                     let type = getTypeAnnotationFromAccessor(node);
                     if (!type) {
                         // couldn't get type for the first accessor, try the another one
-                        let anotherAccessor = node.kind === SyntaxKind.GetAccessor ? accessors.setAccessor : accessors.getAccessor;
+                        const anotherAccessor = node.kind === SyntaxKind.GetAccessor ? accessors.setAccessor : accessors.getAccessor;
                         type = getTypeAnnotationFromAccessor(anotherAccessor);
                         if (type) {
                             accessorWithTypeAnnotation = anotherAccessor;
@@ -1230,13 +1279,13 @@ namespace ts {
                 }
                 if (node.kind === SyntaxKind.FunctionDeclaration) {
                     write("function ");
-                    writeTextOfNode(currentSourceFile, node.name);
+                    writeTextOfNode(currentText, node.name);
                 }
                 else if (node.kind === SyntaxKind.Constructor) {
                     write("constructor");
                 }
                 else {
-                    writeTextOfNode(currentSourceFile, node.name);
+                    writeTextOfNode(currentText, node.name);
                     if (hasQuestionToken(node)) {
                         write("?");
                     }
@@ -1263,7 +1312,7 @@ namespace ts {
                 write("(");
             }
 
-            let prevEnclosingDeclaration = enclosingDeclaration;
+            const prevEnclosingDeclaration = enclosingDeclaration;
             enclosingDeclaration = node;
 
             // Parameters
@@ -1277,7 +1326,7 @@ namespace ts {
             }
 
             // If this is not a constructor and is not private, emit the return type
-            let isFunctionTypeOrConstructorType = node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.ConstructorType;
+            const isFunctionTypeOrConstructorType = node.kind === SyntaxKind.FunctionType || node.kind === SyntaxKind.ConstructorType;
             if (isFunctionTypeOrConstructorType || node.parent.kind === SyntaxKind.TypeLiteral) {
                 // Emit type literal signature return type only if specified
                 if (node.type) {
@@ -1376,7 +1425,7 @@ namespace ts {
                 emitBindingPattern(<BindingPattern>node.name);
             }
             else {
-                writeTextOfNode(currentSourceFile, node.name);
+                writeTextOfNode(currentText, node.name);
             }
             if (resolver.isOptionalParameter(node)) {
                 write("?");
@@ -1393,7 +1442,7 @@ namespace ts {
             }
 
             function getParameterDeclarationTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                let diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                const diagnosticMessage: DiagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                 return diagnosticMessage !== undefined ? {
                     diagnosticMessage,
                     errorNode: node,
@@ -1466,7 +1515,7 @@ namespace ts {
                 }
                 else if (bindingPattern.kind === SyntaxKind.ArrayBindingPattern) {
                     write("[");
-                    let elements = bindingPattern.elements;
+                    const elements = bindingPattern.elements;
                     emitCommaList(elements, emitBindingElement);
                     if (elements && elements.hasTrailingComma) {
                         write(", ");
@@ -1477,7 +1526,7 @@ namespace ts {
 
             function emitBindingElement(bindingElement: BindingElement) {
                 function getBindingElementTypeVisibilityError(symbolAccesibilityResult: SymbolAccessiblityResult): SymbolAccessibilityDiagnostic {
-                    let diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
+                    const diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccesibilityResult);
                     return diagnosticMessage !== undefined ? {
                         diagnosticMessage,
                         errorNode: bindingElement,
@@ -1502,7 +1551,7 @@ namespace ts {
                         // Example:
                         //      original: function foo({y: [a,b,c]}) {}
                         //      emit    : declare function foo({y: [a, b, c]}: { y: [any, any, any] }) void;
-                        writeTextOfNode(currentSourceFile, bindingElement.propertyName);
+                        writeTextOfNode(currentText, bindingElement.propertyName);
                         write(": ");
                     }
                     if (bindingElement.name) {
@@ -1525,7 +1574,7 @@ namespace ts {
                             if (bindingElement.dotDotDotToken) {
                                 write("...");
                             }
-                            writeTextOfNode(currentSourceFile, bindingElement.name);
+                            writeTextOfNode(currentText, bindingElement.name);
                         }
                     }
                 }
@@ -1572,34 +1621,58 @@ namespace ts {
             }
         }
 
-        function writeReferencePath(referencedFile: SourceFile) {
-            let declFileName = referencedFile.flags & NodeFlags.DeclarationFile
-                ? referencedFile.fileName // Declaration file, use declaration file name
-                : shouldEmitToOwnFile(referencedFile, compilerOptions)
-                    ? getOwnEmitOutputFilePath(referencedFile, host, ".d.ts") // Own output file so get the .d.ts file
-                    : removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts"; // Global out file
+        /**
+         * Adds the reference to referenced file, returns true if global file reference was emitted
+         * @param referencedFile
+         * @param addBundledFileReference Determines if global file reference corresponding to bundled file should be emitted or not
+         */
+        function writeReferencePath(referencedFile: SourceFile, addBundledFileReference: boolean): boolean {
+            let declFileName: string;
+            let addedBundledEmitReference = false;
+            if (isDeclarationFile(referencedFile)) {
+                // Declaration file, use declaration file name
+                declFileName = referencedFile.fileName;
+            }
+            else {
+                // Get the declaration file path
+                forEachExpectedEmitFile(host, getDeclFileName, referencedFile);
+            }
 
-            declFileName = getRelativePathToDirectoryOrUrl(
-                getDirectoryPath(normalizeSlashes(jsFilePath)),
-                declFileName,
-                host.getCurrentDirectory(),
-                host.getCanonicalFileName,
-            /*isAbsolutePathAnUrl*/ false);
+            if (declFileName) {
+                declFileName = getRelativePathToDirectoryOrUrl(
+                    getDirectoryPath(normalizeSlashes(declarationFilePath)),
+                    declFileName,
+                    host.getCurrentDirectory(),
+                    host.getCanonicalFileName,
+                    /*isAbsolutePathAnUrl*/ false);
 
-            referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
+                referencePathsOutput += "/// <reference path=\"" + declFileName + "\" />" + newLine;
+            }
+            return addedBundledEmitReference;
+
+            function getDeclFileName(emitFileNames: EmitFileNames, sourceFiles: SourceFile[], isBundledEmit: boolean) {
+                // Dont add reference path to this file if it is a bundled emit and caller asked not emit bundled file path
+                if (isBundledEmit && !addBundledFileReference) {
+                    return;
+                }
+
+                Debug.assert(!!emitFileNames.declarationFilePath || isSourceFileJavaScript(referencedFile), "Declaration file is not present only for javascript files");
+                declFileName = emitFileNames.declarationFilePath || emitFileNames.jsFilePath;
+                addedBundledEmitReference = isBundledEmit;
+            }
         }
     }
 
     /* @internal */
-    export function writeDeclarationFile(jsFilePath: string, sourceFile: SourceFile, host: EmitHost, resolver: EmitResolver, diagnostics: Diagnostic[]) {
-        let emitDeclarationResult = emitDeclarations(host, resolver, diagnostics, jsFilePath, sourceFile);
-        // TODO(shkamat): Should we not write any declaration file if any of them can produce error,
-        // or should we just not write this file like we are doing now
-        if (!emitDeclarationResult.reportedDeclarationError) {
-            let declarationOutput = emitDeclarationResult.referencePathsOutput
+    export function writeDeclarationFile(declarationFilePath: string, sourceFiles: SourceFile[], isBundledEmit: boolean, host: EmitHost, resolver: EmitResolver, emitterDiagnostics: DiagnosticCollection) {
+        const emitDeclarationResult = emitDeclarations(host, resolver, emitterDiagnostics, declarationFilePath, sourceFiles, isBundledEmit);
+        const emitSkipped = emitDeclarationResult.reportedDeclarationError || host.isEmitBlocked(declarationFilePath);
+        if (!emitSkipped) {
+            const declarationOutput = emitDeclarationResult.referencePathsOutput
                 + getDeclarationOutput(emitDeclarationResult.synchronousDeclarationOutput, emitDeclarationResult.moduleElementDeclarationEmitInfo);
-            writeFile(host, diagnostics, removeFileExtension(jsFilePath) + ".d.ts", declarationOutput, host.getCompilerOptions().emitBOM);
+            writeFile(host, emitterDiagnostics, declarationFilePath, declarationOutput, host.getCompilerOptions().emitBOM);
         }
+        return emitSkipped;
 
         function getDeclarationOutput(synchronousDeclarationOutput: string, moduleElementDeclarationEmitInfo: ModuleElementDeclarationEmitInfo[]) {
             let appliedSyncOutputPos = 0;

src/compiler/diagnosticInformationMap.generated.ts

@@ -1,617 +0,0 @@
-// <auto-generated />
-/// <reference path="types.ts" />
-/* @internal */
-namespace ts {
-    export var Diagnostics = {
-        Unterminated_string_literal: { code: 1002, category: DiagnosticCategory.Error, key: "Unterminated string literal." },
-        Identifier_expected: { code: 1003, category: DiagnosticCategory.Error, key: "Identifier expected." },
-        _0_expected: { code: 1005, category: DiagnosticCategory.Error, key: "'{0}' expected." },
-        A_file_cannot_have_a_reference_to_itself: { code: 1006, category: DiagnosticCategory.Error, key: "A file cannot have a reference to itself." },
-        Trailing_comma_not_allowed: { code: 1009, category: DiagnosticCategory.Error, key: "Trailing comma not allowed." },
-        Asterisk_Slash_expected: { code: 1010, category: DiagnosticCategory.Error, key: "'*/' expected." },
-        Unexpected_token: { code: 1012, category: DiagnosticCategory.Error, key: "Unexpected token." },
-        A_rest_parameter_must_be_last_in_a_parameter_list: { code: 1014, category: DiagnosticCategory.Error, key: "A rest parameter must be last in a parameter list." },
-        Parameter_cannot_have_question_mark_and_initializer: { code: 1015, category: DiagnosticCategory.Error, key: "Parameter cannot have question mark and initializer." },
-        A_required_parameter_cannot_follow_an_optional_parameter: { code: 1016, category: DiagnosticCategory.Error, key: "A required parameter cannot follow an optional parameter." },
-        An_index_signature_cannot_have_a_rest_parameter: { code: 1017, category: DiagnosticCategory.Error, key: "An index signature cannot have a rest parameter." },
-        An_index_signature_parameter_cannot_have_an_accessibility_modifier: { code: 1018, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an accessibility modifier." },
-        An_index_signature_parameter_cannot_have_a_question_mark: { code: 1019, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have a question mark." },
-        An_index_signature_parameter_cannot_have_an_initializer: { code: 1020, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an initializer." },
-        An_index_signature_must_have_a_type_annotation: { code: 1021, category: DiagnosticCategory.Error, key: "An index signature must have a type annotation." },
-        An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: DiagnosticCategory.Error, key: "An index signature parameter must have a type annotation." },
-        An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: DiagnosticCategory.Error, key: "An index signature parameter type must be 'string' or 'number'." },
-        Accessibility_modifier_already_seen: { code: 1028, category: DiagnosticCategory.Error, key: "Accessibility modifier already seen." },
-        _0_modifier_must_precede_1_modifier: { code: 1029, category: DiagnosticCategory.Error, key: "'{0}' modifier must precede '{1}' modifier." },
-        _0_modifier_already_seen: { code: 1030, category: DiagnosticCategory.Error, key: "'{0}' modifier already seen." },
-        _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a class element." },
-        super_must_be_followed_by_an_argument_list_or_member_access: { code: 1034, category: DiagnosticCategory.Error, key: "'super' must be followed by an argument list or member access." },
-        Only_ambient_modules_can_use_quoted_names: { code: 1035, category: DiagnosticCategory.Error, key: "Only ambient modules can use quoted names." },
-        Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: DiagnosticCategory.Error, key: "Statements are not allowed in ambient contexts." },
-        A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used in an already ambient context." },
-        Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: DiagnosticCategory.Error, key: "Initializers are not allowed in ambient contexts." },
-        _0_modifier_cannot_be_used_in_an_ambient_context: { code: 1040, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used in an ambient context." },
-        _0_modifier_cannot_be_used_with_a_class_declaration: { code: 1041, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a class declaration." },
-        _0_modifier_cannot_be_used_here: { code: 1042, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used here." },
-        _0_modifier_cannot_appear_on_a_data_property: { code: 1043, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a data property." },
-        _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a module element." },
-        A_0_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A '{0}' modifier cannot be used with an interface declaration." },
-        A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: { code: 1046, category: DiagnosticCategory.Error, key: "A 'declare' modifier is required for a top level declaration in a .d.ts file." },
-        A_rest_parameter_cannot_be_optional: { code: 1047, category: DiagnosticCategory.Error, key: "A rest parameter cannot be optional." },
-        A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: DiagnosticCategory.Error, key: "A rest parameter cannot have an initializer." },
-        A_set_accessor_must_have_exactly_one_parameter: { code: 1049, category: DiagnosticCategory.Error, key: "A 'set' accessor must have exactly one parameter." },
-        A_set_accessor_cannot_have_an_optional_parameter: { code: 1051, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have an optional parameter." },
-        A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: DiagnosticCategory.Error, key: "A 'set' accessor parameter cannot have an initializer." },
-        A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have rest parameter." },
-        A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters." },
-        Type_0_is_not_a_valid_async_function_return_type: { code: 1055, category: DiagnosticCategory.Error, key: "Type '{0}' is not a valid async function return type." },
-        Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." },
-        An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: DiagnosticCategory.Error, key: "An async function or method must have a valid awaitable return type." },
-        Operand_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Operand for 'await' does not have a valid callable 'then' member." },
-        Return_expression_in_async_function_does_not_have_a_valid_callable_then_member: { code: 1059, category: DiagnosticCategory.Error, key: "Return expression in async function does not have a valid callable 'then' member." },
-        Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member: { code: 1060, category: DiagnosticCategory.Error, key: "Expression body for async arrow function does not have a valid callable 'then' member." },
-        Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." },
-        _0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: { code: 1062, category: DiagnosticCategory.Error, key: "{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method." },
-        An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a namespace." },
-        Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." },
-        Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." },
-        A_0_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A '{0}' modifier cannot be used with an import declaration." },
-        Invalid_reference_directive_syntax: { code: 1084, category: DiagnosticCategory.Error, key: "Invalid 'reference' directive syntax." },
-        Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: DiagnosticCategory.Error, key: "Octal literals are not available when targeting ECMAScript 5 and higher." },
-        An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: DiagnosticCategory.Error, key: "An accessor cannot be declared in an ambient context." },
-        _0_modifier_cannot_appear_on_a_constructor_declaration: { code: 1089, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a constructor declaration." },
-        _0_modifier_cannot_appear_on_a_parameter: { code: 1090, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a parameter." },
-        Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: { code: 1091, category: DiagnosticCategory.Error, key: "Only a single variable declaration is allowed in a 'for...in' statement." },
-        Type_parameters_cannot_appear_on_a_constructor_declaration: { code: 1092, category: DiagnosticCategory.Error, key: "Type parameters cannot appear on a constructor declaration." },
-        Type_annotation_cannot_appear_on_a_constructor_declaration: { code: 1093, category: DiagnosticCategory.Error, key: "Type annotation cannot appear on a constructor declaration." },
-        An_accessor_cannot_have_type_parameters: { code: 1094, category: DiagnosticCategory.Error, key: "An accessor cannot have type parameters." },
-        A_set_accessor_cannot_have_a_return_type_annotation: { code: 1095, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have a return type annotation." },
-        An_index_signature_must_have_exactly_one_parameter: { code: 1096, category: DiagnosticCategory.Error, key: "An index signature must have exactly one parameter." },
-        _0_list_cannot_be_empty: { code: 1097, category: DiagnosticCategory.Error, key: "'{0}' list cannot be empty." },
-        Type_parameter_list_cannot_be_empty: { code: 1098, category: DiagnosticCategory.Error, key: "Type parameter list cannot be empty." },
-        Type_argument_list_cannot_be_empty: { code: 1099, category: DiagnosticCategory.Error, key: "Type argument list cannot be empty." },
-        Invalid_use_of_0_in_strict_mode: { code: 1100, category: DiagnosticCategory.Error, key: "Invalid use of '{0}' in strict mode." },
-        with_statements_are_not_allowed_in_strict_mode: { code: 1101, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in strict mode." },
-        delete_cannot_be_called_on_an_identifier_in_strict_mode: { code: 1102, category: DiagnosticCategory.Error, key: "'delete' cannot be called on an identifier in strict mode." },
-        A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: { code: 1104, category: DiagnosticCategory.Error, key: "A 'continue' statement can only be used within an enclosing iteration statement." },
-        A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: { code: 1105, category: DiagnosticCategory.Error, key: "A 'break' statement can only be used within an enclosing iteration or switch statement." },
-        Jump_target_cannot_cross_function_boundary: { code: 1107, category: DiagnosticCategory.Error, key: "Jump target cannot cross function boundary." },
-        A_return_statement_can_only_be_used_within_a_function_body: { code: 1108, category: DiagnosticCategory.Error, key: "A 'return' statement can only be used within a function body." },
-        Expression_expected: { code: 1109, category: DiagnosticCategory.Error, key: "Expression expected." },
-        Type_expected: { code: 1110, category: DiagnosticCategory.Error, key: "Type expected." },
-        A_class_member_cannot_be_declared_optional: { code: 1112, category: DiagnosticCategory.Error, key: "A class member cannot be declared optional." },
-        A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: { code: 1113, category: DiagnosticCategory.Error, key: "A 'default' clause cannot appear more than once in a 'switch' statement." },
-        Duplicate_label_0: { code: 1114, category: DiagnosticCategory.Error, key: "Duplicate label '{0}'" },
-        A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: { code: 1115, category: DiagnosticCategory.Error, key: "A 'continue' statement can only jump to a label of an enclosing iteration statement." },
-        A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: { code: 1116, category: DiagnosticCategory.Error, key: "A 'break' statement can only jump to a label of an enclosing statement." },
-        An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: { code: 1117, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple properties with the same name in strict mode." },
-        An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple get/set accessors with the same name." },
-        An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: DiagnosticCategory.Error, key: "An object literal cannot have property and accessor with the same name." },
-        An_export_assignment_cannot_have_modifiers: { code: 1120, category: DiagnosticCategory.Error, key: "An export assignment cannot have modifiers." },
-        Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: DiagnosticCategory.Error, key: "Octal literals are not allowed in strict mode." },
-        A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: DiagnosticCategory.Error, key: "A tuple type element list cannot be empty." },
-        Variable_declaration_list_cannot_be_empty: { code: 1123, category: DiagnosticCategory.Error, key: "Variable declaration list cannot be empty." },
-        Digit_expected: { code: 1124, category: DiagnosticCategory.Error, key: "Digit expected." },
-        Hexadecimal_digit_expected: { code: 1125, category: DiagnosticCategory.Error, key: "Hexadecimal digit expected." },
-        Unexpected_end_of_text: { code: 1126, category: DiagnosticCategory.Error, key: "Unexpected end of text." },
-        Invalid_character: { code: 1127, category: DiagnosticCategory.Error, key: "Invalid character." },
-        Declaration_or_statement_expected: { code: 1128, category: DiagnosticCategory.Error, key: "Declaration or statement expected." },
-        Statement_expected: { code: 1129, category: DiagnosticCategory.Error, key: "Statement expected." },
-        case_or_default_expected: { code: 1130, category: DiagnosticCategory.Error, key: "'case' or 'default' expected." },
-        Property_or_signature_expected: { code: 1131, category: DiagnosticCategory.Error, key: "Property or signature expected." },
-        Enum_member_expected: { code: 1132, category: DiagnosticCategory.Error, key: "Enum member expected." },
-        Variable_declaration_expected: { code: 1134, category: DiagnosticCategory.Error, key: "Variable declaration expected." },
-        Argument_expression_expected: { code: 1135, category: DiagnosticCategory.Error, key: "Argument expression expected." },
-        Property_assignment_expected: { code: 1136, category: DiagnosticCategory.Error, key: "Property assignment expected." },
-        Expression_or_comma_expected: { code: 1137, category: DiagnosticCategory.Error, key: "Expression or comma expected." },
-        Parameter_declaration_expected: { code: 1138, category: DiagnosticCategory.Error, key: "Parameter declaration expected." },
-        Type_parameter_declaration_expected: { code: 1139, category: DiagnosticCategory.Error, key: "Type parameter declaration expected." },
-        Type_argument_expected: { code: 1140, category: DiagnosticCategory.Error, key: "Type argument expected." },
-        String_literal_expected: { code: 1141, category: DiagnosticCategory.Error, key: "String literal expected." },
-        Line_break_not_permitted_here: { code: 1142, category: DiagnosticCategory.Error, key: "Line break not permitted here." },
-        or_expected: { code: 1144, category: DiagnosticCategory.Error, key: "'{' or ';' expected." },
-        Modifiers_not_permitted_on_index_signature_members: { code: 1145, category: DiagnosticCategory.Error, key: "Modifiers not permitted on index signature members." },
-        Declaration_expected: { code: 1146, category: DiagnosticCategory.Error, key: "Declaration expected." },
-        Import_declarations_in_a_namespace_cannot_reference_a_module: { code: 1147, category: DiagnosticCategory.Error, key: "Import declarations in a namespace cannot reference a module." },
-        Cannot_compile_modules_unless_the_module_flag_is_provided: { code: 1148, category: DiagnosticCategory.Error, key: "Cannot compile modules unless the '--module' flag is provided." },
-        File_name_0_differs_from_already_included_file_name_1_only_in_casing: { code: 1149, category: DiagnosticCategory.Error, key: "File name '{0}' differs from already included file name '{1}' only in casing" },
-        new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead." },
-        const_declarations_must_be_initialized: { code: 1155, category: DiagnosticCategory.Error, key: "'const' declarations must be initialized" },
-        const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block." },
-        let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." },
-        Unterminated_template_literal: { code: 1160, category: DiagnosticCategory.Error, key: "Unterminated template literal." },
-        Unterminated_regular_expression_literal: { code: 1161, category: DiagnosticCategory.Error, key: "Unterminated regular expression literal." },
-        An_object_member_cannot_be_declared_optional: { code: 1162, category: DiagnosticCategory.Error, key: "An object member cannot be declared optional." },
-        A_yield_expression_is_only_allowed_in_a_generator_body: { code: 1163, category: DiagnosticCategory.Error, key: "A 'yield' expression is only allowed in a generator body." },
-        Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums." },
-        A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol: { code: 1165, category: DiagnosticCategory.Error, key: "A computed property name in an ambient context must directly refer to a built-in symbol." },
-        A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol: { code: 1166, category: DiagnosticCategory.Error, key: "A computed property name in a class property declaration must directly refer to a built-in symbol." },
-        A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol: { code: 1168, category: DiagnosticCategory.Error, key: "A computed property name in a method overload must directly refer to a built-in symbol." },
-        A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol: { code: 1169, category: DiagnosticCategory.Error, key: "A computed property name in an interface must directly refer to a built-in symbol." },
-        A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol: { code: 1170, category: DiagnosticCategory.Error, key: "A computed property name in a type literal must directly refer to a built-in symbol." },
-        A_comma_expression_is_not_allowed_in_a_computed_property_name: { code: 1171, category: DiagnosticCategory.Error, key: "A comma expression is not allowed in a computed property name." },
-        extends_clause_already_seen: { code: 1172, category: DiagnosticCategory.Error, key: "'extends' clause already seen." },
-        extends_clause_must_precede_implements_clause: { code: 1173, category: DiagnosticCategory.Error, key: "'extends' clause must precede 'implements' clause." },
-        Classes_can_only_extend_a_single_class: { code: 1174, category: DiagnosticCategory.Error, key: "Classes can only extend a single class." },
-        implements_clause_already_seen: { code: 1175, category: DiagnosticCategory.Error, key: "'implements' clause already seen." },
-        Interface_declaration_cannot_have_implements_clause: { code: 1176, category: DiagnosticCategory.Error, key: "Interface declaration cannot have 'implements' clause." },
-        Binary_digit_expected: { code: 1177, category: DiagnosticCategory.Error, key: "Binary digit expected." },
-        Octal_digit_expected: { code: 1178, category: DiagnosticCategory.Error, key: "Octal digit expected." },
-        Unexpected_token_expected: { code: 1179, category: DiagnosticCategory.Error, key: "Unexpected token. '{' expected." },
-        Property_destructuring_pattern_expected: { code: 1180, category: DiagnosticCategory.Error, key: "Property destructuring pattern expected." },
-        Array_element_destructuring_pattern_expected: { code: 1181, category: DiagnosticCategory.Error, key: "Array element destructuring pattern expected." },
-        A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: DiagnosticCategory.Error, key: "A destructuring declaration must have an initializer." },
-        An_implementation_cannot_be_declared_in_ambient_contexts: { code: 1184, category: DiagnosticCategory.Error, key: "An implementation cannot be declared in ambient contexts." },
-        Modifiers_cannot_appear_here: { code: 1184, category: DiagnosticCategory.Error, key: "Modifiers cannot appear here." },
-        Merge_conflict_marker_encountered: { code: 1185, category: DiagnosticCategory.Error, key: "Merge conflict marker encountered." },
-        A_rest_element_cannot_have_an_initializer: { code: 1186, category: DiagnosticCategory.Error, key: "A rest element cannot have an initializer." },
-        A_parameter_property_may_not_be_a_binding_pattern: { code: 1187, category: DiagnosticCategory.Error, key: "A parameter property may not be a binding pattern." },
-        Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: DiagnosticCategory.Error, key: "Only a single variable declaration is allowed in a 'for...of' statement." },
-        The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: DiagnosticCategory.Error, key: "The variable declaration of a 'for...in' statement cannot have an initializer." },
-        The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: DiagnosticCategory.Error, key: "The variable declaration of a 'for...of' statement cannot have an initializer." },
-        An_import_declaration_cannot_have_modifiers: { code: 1191, category: DiagnosticCategory.Error, key: "An import declaration cannot have modifiers." },
-        Module_0_has_no_default_export: { code: 1192, category: DiagnosticCategory.Error, key: "Module '{0}' has no default export." },
-        An_export_declaration_cannot_have_modifiers: { code: 1193, category: DiagnosticCategory.Error, key: "An export declaration cannot have modifiers." },
-        Export_declarations_are_not_permitted_in_a_namespace: { code: 1194, category: DiagnosticCategory.Error, key: "Export declarations are not permitted in a namespace." },
-        Catch_clause_variable_name_must_be_an_identifier: { code: 1195, category: DiagnosticCategory.Error, key: "Catch clause variable name must be an identifier." },
-        Catch_clause_variable_cannot_have_a_type_annotation: { code: 1196, category: DiagnosticCategory.Error, key: "Catch clause variable cannot have a type annotation." },
-        Catch_clause_variable_cannot_have_an_initializer: { code: 1197, category: DiagnosticCategory.Error, key: "Catch clause variable cannot have an initializer." },
-        An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: { code: 1198, category: DiagnosticCategory.Error, key: "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive." },
-        Unterminated_Unicode_escape_sequence: { code: 1199, category: DiagnosticCategory.Error, key: "Unterminated Unicode escape sequence." },
-        Line_terminator_not_permitted_before_arrow: { code: 1200, category: DiagnosticCategory.Error, key: "Line terminator not permitted before arrow." },
-        Import_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_or_import_d_from_mod_instead: { code: 1202, category: DiagnosticCategory.Error, key: "Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"' or 'import d from \"mod\"' instead." },
-        Export_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_export_default_instead: { code: 1203, category: DiagnosticCategory.Error, key: "Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead." },
-        Cannot_compile_modules_into_commonjs_amd_system_or_umd_when_targeting_ES6_or_higher: { code: 1204, category: DiagnosticCategory.Error, key: "Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher." },
-        Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1205, category: DiagnosticCategory.Error, key: "Decorators are only available when targeting ECMAScript 5 and higher." },
-        Decorators_are_not_valid_here: { code: 1206, category: DiagnosticCategory.Error, key: "Decorators are not valid here." },
-        Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: { code: 1207, category: DiagnosticCategory.Error, key: "Decorators cannot be applied to multiple get/set accessors of the same name." },
-        Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided: { code: 1208, category: DiagnosticCategory.Error, key: "Cannot compile namespaces when the '--isolatedModules' flag is provided." },
-        Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided: { code: 1209, category: DiagnosticCategory.Error, key: "Ambient const enums are not allowed when the '--isolatedModules' flag is provided." },
-        Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: { code: 1210, category: DiagnosticCategory.Error, key: "Invalid use of '{0}'. Class definitions are automatically in strict mode." },
-        A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" },
-        Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode" },
-        Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." },
-        Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." },
-        Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: DiagnosticCategory.Error, key: "Invalid use of '{0}'. Modules are automatically in strict mode." },
-        Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." },
-        Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning: { code: 1219, category: DiagnosticCategory.Error, key: "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning." },
-        Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1220, category: DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." },
-        Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." },
-        An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." },
-        _0_tag_already_specified: { code: 1223, category: DiagnosticCategory.Error, key: "'{0}' tag already specified." },
-        Signature_0_must_have_a_type_predicate: { code: 1224, category: DiagnosticCategory.Error, key: "Signature '{0}' must have a type predicate." },
-        Cannot_find_parameter_0: { code: 1225, category: DiagnosticCategory.Error, key: "Cannot find parameter '{0}'." },
-        Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." },
-        Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." },
-        A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." },
-        A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." },
-        A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." },
-        An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: DiagnosticCategory.Error, key: "An export assignment can only be used in a module." },
-        An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: DiagnosticCategory.Error, key: "An import declaration can only be used in a namespace or module." },
-        An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: DiagnosticCategory.Error, key: "An export declaration can only be used in a module." },
-        An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." },
-        A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." },
-        Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning: { code: 1236, category: DiagnosticCategory.Error, key: "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning." },
-        with_statements_are_not_allowed_in_an_async_function_block: { code: 1300, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in an async function block." },
-        await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: DiagnosticCategory.Error, key: "'await' expression is only allowed within an async function." },
-        Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: DiagnosticCategory.Error, key: "Async functions are only available when targeting ECMAScript 6 and higher." },
-        The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." },
-        The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." },
-        Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." },
-        Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." },
-        Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." },
-        Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." },
-        abstract_modifier_can_only_appear_on_a_class_or_method_declaration: { code: 1242, category: DiagnosticCategory.Error, key: "'abstract' modifier can only appear on a class or method declaration." },
-        _0_modifier_cannot_be_used_with_1_modifier: { code: 1243, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with '{1}' modifier." },
-        Abstract_methods_can_only_appear_within_an_abstract_class: { code: 1244, category: DiagnosticCategory.Error, key: "Abstract methods can only appear within an abstract class." },
-        Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: { code: 1245, category: DiagnosticCategory.Error, key: "Method '{0}' cannot have an implementation because it is marked abstract." },
-        Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
-        Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
-        Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
-        Circular_definition_of_import_alias_0: { code: 2303, category: DiagnosticCategory.Error, key: "Circular definition of import alias '{0}'." },
-        Cannot_find_name_0: { code: 2304, category: DiagnosticCategory.Error, key: "Cannot find name '{0}'." },
-        Module_0_has_no_exported_member_1: { code: 2305, category: DiagnosticCategory.Error, key: "Module '{0}' has no exported member '{1}'." },
-        File_0_is_not_a_module: { code: 2306, category: DiagnosticCategory.Error, key: "File '{0}' is not a module." },
-        Cannot_find_module_0: { code: 2307, category: DiagnosticCategory.Error, key: "Cannot find module '{0}'." },
-        An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: { code: 2309, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a module with other exported elements." },
-        Type_0_recursively_references_itself_as_a_base_type: { code: 2310, category: DiagnosticCategory.Error, key: "Type '{0}' recursively references itself as a base type." },
-        A_class_may_only_extend_another_class: { code: 2311, category: DiagnosticCategory.Error, key: "A class may only extend another class." },
-        An_interface_may_only_extend_a_class_or_another_interface: { code: 2312, category: DiagnosticCategory.Error, key: "An interface may only extend a class or another interface." },
-        Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list: { code: 2313, category: DiagnosticCategory.Error, key: "Constraint of a type parameter cannot reference any type parameter from the same type parameter list." },
-        Generic_type_0_requires_1_type_argument_s: { code: 2314, category: DiagnosticCategory.Error, key: "Generic type '{0}' requires {1} type argument(s)." },
-        Type_0_is_not_generic: { code: 2315, category: DiagnosticCategory.Error, key: "Type '{0}' is not generic." },
-        Global_type_0_must_be_a_class_or_interface_type: { code: 2316, category: DiagnosticCategory.Error, key: "Global type '{0}' must be a class or interface type." },
-        Global_type_0_must_have_1_type_parameter_s: { code: 2317, category: DiagnosticCategory.Error, key: "Global type '{0}' must have {1} type parameter(s)." },
-        Cannot_find_global_type_0: { code: 2318, category: DiagnosticCategory.Error, key: "Cannot find global type '{0}'." },
-        Named_property_0_of_types_1_and_2_are_not_identical: { code: 2319, category: DiagnosticCategory.Error, key: "Named property '{0}' of types '{1}' and '{2}' are not identical." },
-        Interface_0_cannot_simultaneously_extend_types_1_and_2: { code: 2320, category: DiagnosticCategory.Error, key: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'." },
-        Excessive_stack_depth_comparing_types_0_and_1: { code: 2321, category: DiagnosticCategory.Error, key: "Excessive stack depth comparing types '{0}' and '{1}'." },
-        Type_0_is_not_assignable_to_type_1: { code: 2322, category: DiagnosticCategory.Error, key: "Type '{0}' is not assignable to type '{1}'." },
-        Property_0_is_missing_in_type_1: { code: 2324, category: DiagnosticCategory.Error, key: "Property '{0}' is missing in type '{1}'." },
-        Property_0_is_private_in_type_1_but_not_in_type_2: { code: 2325, category: DiagnosticCategory.Error, key: "Property '{0}' is private in type '{1}' but not in type '{2}'." },
-        Types_of_property_0_are_incompatible: { code: 2326, category: DiagnosticCategory.Error, key: "Types of property '{0}' are incompatible." },
-        Property_0_is_optional_in_type_1_but_required_in_type_2: { code: 2327, category: DiagnosticCategory.Error, key: "Property '{0}' is optional in type '{1}' but required in type '{2}'." },
-        Types_of_parameters_0_and_1_are_incompatible: { code: 2328, category: DiagnosticCategory.Error, key: "Types of parameters '{0}' and '{1}' are incompatible." },
-        Index_signature_is_missing_in_type_0: { code: 2329, category: DiagnosticCategory.Error, key: "Index signature is missing in type '{0}'." },
-        Index_signatures_are_incompatible: { code: 2330, category: DiagnosticCategory.Error, key: "Index signatures are incompatible." },
-        this_cannot_be_referenced_in_a_module_or_namespace_body: { code: 2331, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a module or namespace body." },
-        this_cannot_be_referenced_in_current_location: { code: 2332, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in current location." },
-        this_cannot_be_referenced_in_constructor_arguments: { code: 2333, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in constructor arguments." },
-        this_cannot_be_referenced_in_a_static_property_initializer: { code: 2334, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a static property initializer." },
-        super_can_only_be_referenced_in_a_derived_class: { code: 2335, category: DiagnosticCategory.Error, key: "'super' can only be referenced in a derived class." },
-        super_cannot_be_referenced_in_constructor_arguments: { code: 2336, category: DiagnosticCategory.Error, key: "'super' cannot be referenced in constructor arguments." },
-        Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: { code: 2337, category: DiagnosticCategory.Error, key: "Super calls are not permitted outside constructors or in nested functions inside constructors." },
-        super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: { code: 2338, category: DiagnosticCategory.Error, key: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class." },
-        Property_0_does_not_exist_on_type_1: { code: 2339, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist on type '{1}'." },
-        Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: { code: 2340, category: DiagnosticCategory.Error, key: "Only public and protected methods of the base class are accessible via the 'super' keyword." },
-        Property_0_is_private_and_only_accessible_within_class_1: { code: 2341, category: DiagnosticCategory.Error, key: "Property '{0}' is private and only accessible within class '{1}'." },
-        An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: { code: 2342, category: DiagnosticCategory.Error, key: "An index expression argument must be of type 'string', 'number', 'symbol', or 'any'." },
-        Type_0_does_not_satisfy_the_constraint_1: { code: 2344, category: DiagnosticCategory.Error, key: "Type '{0}' does not satisfy the constraint '{1}'." },
-        Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: { code: 2345, category: DiagnosticCategory.Error, key: "Argument of type '{0}' is not assignable to parameter of type '{1}'." },
-        Supplied_parameters_do_not_match_any_signature_of_call_target: { code: 2346, category: DiagnosticCategory.Error, key: "Supplied parameters do not match any signature of call target." },
-        Untyped_function_calls_may_not_accept_type_arguments: { code: 2347, category: DiagnosticCategory.Error, key: "Untyped function calls may not accept type arguments." },
-        Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: { code: 2348, category: DiagnosticCategory.Error, key: "Value of type '{0}' is not callable. Did you mean to include 'new'?" },
-        Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: { code: 2349, category: DiagnosticCategory.Error, key: "Cannot invoke an expression whose type lacks a call signature." },
-        Only_a_void_function_can_be_called_with_the_new_keyword: { code: 2350, category: DiagnosticCategory.Error, key: "Only a void function can be called with the 'new' keyword." },
-        Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature: { code: 2351, category: DiagnosticCategory.Error, key: "Cannot use 'new' with an expression whose type lacks a call or construct signature." },
-        Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: DiagnosticCategory.Error, key: "Neither type '{0}' nor type '{1}' is assignable to the other." },
-        Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: DiagnosticCategory.Error, key: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
-        No_best_common_type_exists_among_return_expressions: { code: 2354, category: DiagnosticCategory.Error, key: "No best common type exists among return expressions." },
-        A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: DiagnosticCategory.Error, key: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." },
-        An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: DiagnosticCategory.Error, key: "An arithmetic operand must be of type 'any', 'number' or an enum type." },
-        The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: DiagnosticCategory.Error, key: "The operand of an increment or decrement operator must be a variable, property or indexer." },
-        The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: DiagnosticCategory.Error, key: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." },
-        The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: { code: 2359, category: DiagnosticCategory.Error, key: "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type." },
-        The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: { code: 2360, category: DiagnosticCategory.Error, key: "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'." },
-        The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2361, category: DiagnosticCategory.Error, key: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter" },
-        The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2362, category: DiagnosticCategory.Error, key: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." },
-        The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2363, category: DiagnosticCategory.Error, key: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." },
-        Invalid_left_hand_side_of_assignment_expression: { code: 2364, category: DiagnosticCategory.Error, key: "Invalid left-hand side of assignment expression." },
-        Operator_0_cannot_be_applied_to_types_1_and_2: { code: 2365, category: DiagnosticCategory.Error, key: "Operator '{0}' cannot be applied to types '{1}' and '{2}'." },
-        Type_parameter_name_cannot_be_0: { code: 2368, category: DiagnosticCategory.Error, key: "Type parameter name cannot be '{0}'" },
-        A_parameter_property_is_only_allowed_in_a_constructor_implementation: { code: 2369, category: DiagnosticCategory.Error, key: "A parameter property is only allowed in a constructor implementation." },
-        A_rest_parameter_must_be_of_an_array_type: { code: 2370, category: DiagnosticCategory.Error, key: "A rest parameter must be of an array type." },
-        A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: { code: 2371, category: DiagnosticCategory.Error, key: "A parameter initializer is only allowed in a function or constructor implementation." },
-        Parameter_0_cannot_be_referenced_in_its_initializer: { code: 2372, category: DiagnosticCategory.Error, key: "Parameter '{0}' cannot be referenced in its initializer." },
-        Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: { code: 2373, category: DiagnosticCategory.Error, key: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it." },
-        Duplicate_string_index_signature: { code: 2374, category: DiagnosticCategory.Error, key: "Duplicate string index signature." },
-        Duplicate_number_index_signature: { code: 2375, category: DiagnosticCategory.Error, key: "Duplicate number index signature." },
-        A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: DiagnosticCategory.Error, key: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." },
-        Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: DiagnosticCategory.Error, key: "Constructors for derived classes must contain a 'super' call." },
-        A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: DiagnosticCategory.Error, key: "A 'get' accessor must return a value or consist of a single 'throw' statement." },
-        Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: DiagnosticCategory.Error, key: "Getter and setter accessors do not agree in visibility." },
-        get_and_set_accessor_must_have_the_same_type: { code: 2380, category: DiagnosticCategory.Error, key: "'get' and 'set' accessor must have the same type." },
-        A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: DiagnosticCategory.Error, key: "A signature with an implementation cannot use a string literal type." },
-        Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: { code: 2382, category: DiagnosticCategory.Error, key: "Specialized overload signature is not assignable to any non-specialized signature." },
-        Overload_signatures_must_all_be_exported_or_not_exported: { code: 2383, category: DiagnosticCategory.Error, key: "Overload signatures must all be exported or not exported." },
-        Overload_signatures_must_all_be_ambient_or_non_ambient: { code: 2384, category: DiagnosticCategory.Error, key: "Overload signatures must all be ambient or non-ambient." },
-        Overload_signatures_must_all_be_public_private_or_protected: { code: 2385, category: DiagnosticCategory.Error, key: "Overload signatures must all be public, private or protected." },
-        Overload_signatures_must_all_be_optional_or_required: { code: 2386, category: DiagnosticCategory.Error, key: "Overload signatures must all be optional or required." },
-        Function_overload_must_be_static: { code: 2387, category: DiagnosticCategory.Error, key: "Function overload must be static." },
-        Function_overload_must_not_be_static: { code: 2388, category: DiagnosticCategory.Error, key: "Function overload must not be static." },
-        Function_implementation_name_must_be_0: { code: 2389, category: DiagnosticCategory.Error, key: "Function implementation name must be '{0}'." },
-        Constructor_implementation_is_missing: { code: 2390, category: DiagnosticCategory.Error, key: "Constructor implementation is missing." },
-        Function_implementation_is_missing_or_not_immediately_following_the_declaration: { code: 2391, category: DiagnosticCategory.Error, key: "Function implementation is missing or not immediately following the declaration." },
-        Multiple_constructor_implementations_are_not_allowed: { code: 2392, category: DiagnosticCategory.Error, key: "Multiple constructor implementations are not allowed." },
-        Duplicate_function_implementation: { code: 2393, category: DiagnosticCategory.Error, key: "Duplicate function implementation." },
-        Overload_signature_is_not_compatible_with_function_implementation: { code: 2394, category: DiagnosticCategory.Error, key: "Overload signature is not compatible with function implementation." },
-        Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: { code: 2395, category: DiagnosticCategory.Error, key: "Individual declarations in merged declaration '{0}' must be all exported or all local." },
-        Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: { code: 2396, category: DiagnosticCategory.Error, key: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters." },
-        Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: { code: 2399, category: DiagnosticCategory.Error, key: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference." },
-        Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: { code: 2400, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference." },
-        Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: { code: 2401, category: DiagnosticCategory.Error, key: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference." },
-        Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: { code: 2402, category: DiagnosticCategory.Error, key: "Expression resolves to '_super' that compiler uses to capture base class reference." },
-        Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: { code: 2403, category: DiagnosticCategory.Error, key: "Subsequent variable declarations must have the same type.  Variable '{0}' must be of type '{1}', but here has type '{2}'." },
-        The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: { code: 2404, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot use a type annotation." },
-        The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: { code: 2405, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'." },
-        Invalid_left_hand_side_in_for_in_statement: { code: 2406, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...in' statement." },
-        The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2407, category: DiagnosticCategory.Error, key: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter." },
-        Setters_cannot_return_a_value: { code: 2408, category: DiagnosticCategory.Error, key: "Setters cannot return a value." },
-        Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: { code: 2409, category: DiagnosticCategory.Error, key: "Return type of constructor signature must be assignable to the instance type of the class" },
-        All_symbols_within_a_with_block_will_be_resolved_to_any: { code: 2410, category: DiagnosticCategory.Error, key: "All symbols within a 'with' block will be resolved to 'any'." },
-        Property_0_of_type_1_is_not_assignable_to_string_index_type_2: { code: 2411, category: DiagnosticCategory.Error, key: "Property '{0}' of type '{1}' is not assignable to string index type '{2}'." },
-        Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: { code: 2412, category: DiagnosticCategory.Error, key: "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'." },
-        Numeric_index_type_0_is_not_assignable_to_string_index_type_1: { code: 2413, category: DiagnosticCategory.Error, key: "Numeric index type '{0}' is not assignable to string index type '{1}'." },
-        Class_name_cannot_be_0: { code: 2414, category: DiagnosticCategory.Error, key: "Class name cannot be '{0}'" },
-        Class_0_incorrectly_extends_base_class_1: { code: 2415, category: DiagnosticCategory.Error, key: "Class '{0}' incorrectly extends base class '{1}'." },
-        Class_static_side_0_incorrectly_extends_base_class_static_side_1: { code: 2417, category: DiagnosticCategory.Error, key: "Class static side '{0}' incorrectly extends base class static side '{1}'." },
-        Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0: { code: 2419, category: DiagnosticCategory.Error, key: "Type name '{0}' in extends clause does not reference constructor function for '{0}'." },
-        Class_0_incorrectly_implements_interface_1: { code: 2420, category: DiagnosticCategory.Error, key: "Class '{0}' incorrectly implements interface '{1}'." },
-        A_class_may_only_implement_another_class_or_interface: { code: 2422, category: DiagnosticCategory.Error, key: "A class may only implement another class or interface." },
-        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: { code: 2423, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor." },
-        Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: { code: 2424, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property." },
-        Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2425, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function." },
-        Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2426, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function." },
-        Interface_name_cannot_be_0: { code: 2427, category: DiagnosticCategory.Error, key: "Interface name cannot be '{0}'" },
-        All_declarations_of_an_interface_must_have_identical_type_parameters: { code: 2428, category: DiagnosticCategory.Error, key: "All declarations of an interface must have identical type parameters." },
-        Interface_0_incorrectly_extends_interface_1: { code: 2430, category: DiagnosticCategory.Error, key: "Interface '{0}' incorrectly extends interface '{1}'." },
-        Enum_name_cannot_be_0: { code: 2431, category: DiagnosticCategory.Error, key: "Enum name cannot be '{0}'" },
-        In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: { code: 2432, category: DiagnosticCategory.Error, key: "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element." },
-        A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: { code: 2433, category: DiagnosticCategory.Error, key: "A namespace declaration cannot be in a different file from a class or function with which it is merged" },
-        A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: { code: 2434, category: DiagnosticCategory.Error, key: "A namespace declaration cannot be located prior to a class or function with which it is merged" },
-        Ambient_modules_cannot_be_nested_in_other_modules: { code: 2435, category: DiagnosticCategory.Error, key: "Ambient modules cannot be nested in other modules." },
-        Ambient_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: DiagnosticCategory.Error, key: "Ambient module declaration cannot specify relative module name." },
-        Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: DiagnosticCategory.Error, key: "Module '{0}' is hidden by a local declaration with the same name" },
-        Import_name_cannot_be_0: { code: 2438, category: DiagnosticCategory.Error, key: "Import name cannot be '{0}'" },
-        Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: { code: 2439, category: DiagnosticCategory.Error, key: "Import or export declaration in an ambient module declaration cannot reference module through relative module name." },
-        Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: DiagnosticCategory.Error, key: "Import declaration conflicts with local declaration of '{0}'" },
-        Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: { code: 2441, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module." },
-        Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: DiagnosticCategory.Error, key: "Types have separate declarations of a private property '{0}'." },
-        Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: { code: 2443, category: DiagnosticCategory.Error, key: "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'." },
-        Property_0_is_protected_in_type_1_but_public_in_type_2: { code: 2444, category: DiagnosticCategory.Error, key: "Property '{0}' is protected in type '{1}' but public in type '{2}'." },
-        Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: { code: 2445, category: DiagnosticCategory.Error, key: "Property '{0}' is protected and only accessible within class '{1}' and its subclasses." },
-        Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: { code: 2446, category: DiagnosticCategory.Error, key: "Property '{0}' is protected and only accessible through an instance of class '{1}'." },
-        The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: { code: 2447, category: DiagnosticCategory.Error, key: "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead." },
-        Block_scoped_variable_0_used_before_its_declaration: { code: 2448, category: DiagnosticCategory.Error, key: "Block-scoped variable '{0}' used before its declaration." },
-        The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant: { code: 2449, category: DiagnosticCategory.Error, key: "The operand of an increment or decrement operator cannot be a constant." },
-        Left_hand_side_of_assignment_expression_cannot_be_a_constant: { code: 2450, category: DiagnosticCategory.Error, key: "Left-hand side of assignment expression cannot be a constant." },
-        Cannot_redeclare_block_scoped_variable_0: { code: 2451, category: DiagnosticCategory.Error, key: "Cannot redeclare block-scoped variable '{0}'." },
-        An_enum_member_cannot_have_a_numeric_name: { code: 2452, category: DiagnosticCategory.Error, key: "An enum member cannot have a numeric name." },
-        The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: { code: 2453, category: DiagnosticCategory.Error, key: "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly." },
-        Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: { code: 2455, category: DiagnosticCategory.Error, key: "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'." },
-        Type_alias_0_circularly_references_itself: { code: 2456, category: DiagnosticCategory.Error, key: "Type alias '{0}' circularly references itself." },
-        Type_alias_name_cannot_be_0: { code: 2457, category: DiagnosticCategory.Error, key: "Type alias name cannot be '{0}'" },
-        An_AMD_module_cannot_have_multiple_name_assignments: { code: 2458, category: DiagnosticCategory.Error, key: "An AMD module cannot have multiple name assignments." },
-        Type_0_has_no_property_1_and_no_string_index_signature: { code: 2459, category: DiagnosticCategory.Error, key: "Type '{0}' has no property '{1}' and no string index signature." },
-        Type_0_has_no_property_1: { code: 2460, category: DiagnosticCategory.Error, key: "Type '{0}' has no property '{1}'." },
-        Type_0_is_not_an_array_type: { code: 2461, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type." },
-        A_rest_element_must_be_last_in_an_array_destructuring_pattern: { code: 2462, category: DiagnosticCategory.Error, key: "A rest element must be last in an array destructuring pattern" },
-        A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: { code: 2463, category: DiagnosticCategory.Error, key: "A binding pattern parameter cannot be optional in an implementation signature." },
-        A_computed_property_name_must_be_of_type_string_number_symbol_or_any: { code: 2464, category: DiagnosticCategory.Error, key: "A computed property name must be of type 'string', 'number', 'symbol', or 'any'." },
-        this_cannot_be_referenced_in_a_computed_property_name: { code: 2465, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a computed property name." },
-        super_cannot_be_referenced_in_a_computed_property_name: { code: 2466, category: DiagnosticCategory.Error, key: "'super' cannot be referenced in a computed property name." },
-        A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: { code: 2467, category: DiagnosticCategory.Error, key: "A computed property name cannot reference a type parameter from its containing type." },
-        Cannot_find_global_value_0: { code: 2468, category: DiagnosticCategory.Error, key: "Cannot find global value '{0}'." },
-        The_0_operator_cannot_be_applied_to_type_symbol: { code: 2469, category: DiagnosticCategory.Error, key: "The '{0}' operator cannot be applied to type 'symbol'." },
-        Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: { code: 2470, category: DiagnosticCategory.Error, key: "'Symbol' reference does not refer to the global Symbol constructor object." },
-        A_computed_property_name_of_the_form_0_must_be_of_type_symbol: { code: 2471, category: DiagnosticCategory.Error, key: "A computed property name of the form '{0}' must be of type 'symbol'." },
-        Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: { code: 2472, category: DiagnosticCategory.Error, key: "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher." },
-        Enum_declarations_must_all_be_const_or_non_const: { code: 2473, category: DiagnosticCategory.Error, key: "Enum declarations must all be const or non-const." },
-        In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 2474, category: DiagnosticCategory.Error, key: "In 'const' enum declarations member initializer must be constant expression." },
-        const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment: { code: 2475, category: DiagnosticCategory.Error, key: "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment." },
-        A_const_enum_member_can_only_be_accessed_using_a_string_literal: { code: 2476, category: DiagnosticCategory.Error, key: "A const enum member can only be accessed using a string literal." },
-        const_enum_member_initializer_was_evaluated_to_a_non_finite_value: { code: 2477, category: DiagnosticCategory.Error, key: "'const' enum member initializer was evaluated to a non-finite value." },
-        const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: { code: 2478, category: DiagnosticCategory.Error, key: "'const' enum member initializer was evaluated to disallowed value 'NaN'." },
-        Property_0_does_not_exist_on_const_enum_1: { code: 2479, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist on 'const' enum '{1}'." },
-        let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: { code: 2480, category: DiagnosticCategory.Error, key: "'let' is not allowed to be used as a name in 'let' or 'const' declarations." },
-        Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: DiagnosticCategory.Error, key: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." },
-        The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot use a type annotation." },
-        Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: DiagnosticCategory.Error, key: "Export declaration conflicts with exported declaration of '{0}'" },
-        The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant: { code: 2485, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot be a previously defined constant." },
-        The_left_hand_side_of_a_for_in_statement_cannot_be_a_previously_defined_constant: { code: 2486, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a previously defined constant." },
-        Invalid_left_hand_side_in_for_of_statement: { code: 2487, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...of' statement." },
-        Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "Type must have a '[Symbol.iterator]()' method that returns an iterator." },
-        An_iterator_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "An iterator must have a 'next()' method." },
-        The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: { code: 2490, category: DiagnosticCategory.Error, key: "The type returned by the 'next()' method of an iterator must have a 'value' property." },
-        The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: { code: 2491, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a destructuring pattern." },
-        Cannot_redeclare_identifier_0_in_catch_clause: { code: 2492, category: DiagnosticCategory.Error, key: "Cannot redeclare identifier '{0}' in catch clause" },
-        Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2: { code: 2493, category: DiagnosticCategory.Error, key: "Tuple type '{0}' with length '{1}' cannot be assigned to tuple with length '{2}'." },
-        Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: { code: 2494, category: DiagnosticCategory.Error, key: "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher." },
-        Type_0_is_not_an_array_type_or_a_string_type: { code: 2495, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type or a string type." },
-        The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: { code: 2496, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression." },
-        Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct: { code: 2497, category: DiagnosticCategory.Error, key: "Module '{0}' resolves to a non-module entity and cannot be imported using this construct." },
-        Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: { code: 2498, category: DiagnosticCategory.Error, key: "Module '{0}' uses 'export =' and cannot be used with 'export *'." },
-        An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." },
-        A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." },
-        A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." },
-        _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own type annotation." },
-        Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." },
-        No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." },
-        A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." },
-        _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." },
-        Type_0_is_not_a_constructor_function_type: { code: 2507, category: DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." },
-        No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." },
-        Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." },
-        Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." },
-        Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." },
-        Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be abstract or not abstract." },
-        Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}' in class '{1}' cannot be accessed via super expression." },
-        Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract methods must be marked abstract." },
-        Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." },
-        All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." },
-        Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: { code: 2517, category: DiagnosticCategory.Error, key: "Cannot assign an abstract constructor type to a non-abstract constructor type." },
-        Only_an_ambient_class_can_be_merged_with_an_interface: { code: 2518, category: DiagnosticCategory.Error, key: "Only an ambient class can be merged with an interface." },
-        Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." },
-        Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." },
-        The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression." },
-        yield_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2523, category: DiagnosticCategory.Error, key: "'yield' expressions cannot be used in a parameter initializer." },
-        await_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2524, category: DiagnosticCategory.Error, key: "'await' expressions cannot be used in a parameter initializer." },
-        JSX_element_attributes_type_0_must_be_an_object_type: { code: 2600, category: DiagnosticCategory.Error, key: "JSX element attributes type '{0}' must be an object type." },
-        The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: DiagnosticCategory.Error, key: "The return type of a JSX element constructor must return an object type." },
-        JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: { code: 2602, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist." },
-        Property_0_in_type_1_is_not_assignable_to_type_2: { code: 2603, category: DiagnosticCategory.Error, key: "Property '{0}' in type '{1}' is not assignable to type '{2}'" },
-        JSX_element_type_0_does_not_have_any_construct_or_call_signatures: { code: 2604, category: DiagnosticCategory.Error, key: "JSX element type '{0}' does not have any construct or call signatures." },
-        JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: DiagnosticCategory.Error, key: "JSX element type '{0}' is not a constructor function for JSX elements." },
-        Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: { code: 2606, category: DiagnosticCategory.Error, key: "Property '{0}' of JSX spread attribute is not assignable to target property." },
-        JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: { code: 2607, category: DiagnosticCategory.Error, key: "JSX element class does not support attributes because it does not have a '{0}' property" },
-        The_global_type_JSX_0_may_not_have_more_than_one_property: { code: 2608, category: DiagnosticCategory.Error, key: "The global type 'JSX.{0}' may not have more than one property" },
-        Cannot_emit_namespaced_JSX_elements_in_React: { code: 2650, category: DiagnosticCategory.Error, key: "Cannot emit namespaced JSX elements in React" },
-        A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: { code: 2651, category: DiagnosticCategory.Error, key: "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums." },
-        Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: { code: 2652, category: DiagnosticCategory.Error, key: "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead." },
-        Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: { code: 2653, category: DiagnosticCategory.Error, key: "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'." },
-        Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
-        Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
-        Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4006, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4008, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4010, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'." },
-        Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4012, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of public method from exported class has or is using private name '{1}'." },
-        Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4014, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of method from exported interface has or is using private name '{1}'." },
-        Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4016, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported function has or is using private name '{1}'." },
-        Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4019, category: DiagnosticCategory.Error, key: "Implements clause of exported class '{0}' has or is using private name '{1}'." },
-        Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4020, category: DiagnosticCategory.Error, key: "Extends clause of exported class '{0}' has or is using private name '{1}'." },
-        Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: { code: 4022, category: DiagnosticCategory.Error, key: "Extends clause of exported interface '{0}' has or is using private name '{1}'." },
-        Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4023, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named." },
-        Exported_variable_0_has_or_is_using_name_1_from_private_module_2: { code: 4024, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using name '{1}' from private module '{2}'." },
-        Exported_variable_0_has_or_is_using_private_name_1: { code: 4025, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using private name '{1}'." },
-        Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4026, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4027, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
-        Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using private name '{1}'." },
-        Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4029, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4030, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'." },
-        Public_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4031, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using private name '{1}'." },
-        Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4032, category: DiagnosticCategory.Error, key: "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'." },
-        Property_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4033, category: DiagnosticCategory.Error, key: "Property '{0}' of exported interface has or is using private name '{1}'." },
-        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4034, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static property setter from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4035, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static property setter from exported class has or is using private name '{1}'." },
-        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4036, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public property setter from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4037, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public property setter from exported class has or is using private name '{1}'." },
-        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4038, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4039, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4040, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using private name '{0}'." },
-        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4041, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4042, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4043, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using private name '{0}'." },
-        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4044, category: DiagnosticCategory.Error, key: "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4045, category: DiagnosticCategory.Error, key: "Return type of constructor signature from exported interface has or is using private name '{0}'." },
-        Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4046, category: DiagnosticCategory.Error, key: "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4047, category: DiagnosticCategory.Error, key: "Return type of call signature from exported interface has or is using private name '{0}'." },
-        Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4048, category: DiagnosticCategory.Error, key: "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4049, category: DiagnosticCategory.Error, key: "Return type of index signature from exported interface has or is using private name '{0}'." },
-        Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4050, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4051, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: { code: 4052, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using private name '{0}'." },
-        Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4053, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4054, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: { code: 4055, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using private name '{0}'." },
-        Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4056, category: DiagnosticCategory.Error, key: "Return type of method from exported interface has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: { code: 4057, category: DiagnosticCategory.Error, key: "Return type of method from exported interface has or is using private name '{0}'." },
-        Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4058, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named." },
-        Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: { code: 4059, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using name '{0}' from private module '{1}'." },
-        Return_type_of_exported_function_has_or_is_using_private_name_0: { code: 4060, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using private name '{0}'." },
-        Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4061, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4062, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: { code: 4063, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using private name '{1}'." },
-        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4064, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4065, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." },
-        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4066, category: DiagnosticCategory.Error, key: "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4067, category: DiagnosticCategory.Error, key: "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'." },
-        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4068, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4069, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4070, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using private name '{1}'." },
-        Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4071, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4072, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4073, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using private name '{1}'." },
-        Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4074, category: DiagnosticCategory.Error, key: "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4075, category: DiagnosticCategory.Error, key: "Parameter '{0}' of method from exported interface has or is using private name '{1}'." },
-        Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4076, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named." },
-        Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." },
-        Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using private name '{1}'." },
-        Exported_type_alias_0_has_or_is_using_private_name_1: { code: 4081, category: DiagnosticCategory.Error, key: "Exported type alias '{0}' has or is using private name '{1}'." },
-        Default_export_of_the_module_has_or_is_using_private_name_0: { code: 4082, category: DiagnosticCategory.Error, key: "Default export of the module has or is using private name '{0}'." },
-        Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher: { code: 4091, category: DiagnosticCategory.Error, key: "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher." },
-        The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." },
-        Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." },
-        Cannot_read_file_0_Colon_1: { code: 5012, category: DiagnosticCategory.Error, key: "Cannot read file '{0}': {1}" },
-        Unsupported_file_encoding: { code: 5013, category: DiagnosticCategory.Error, key: "Unsupported file encoding." },
-        Failed_to_parse_file_0_Colon_1: { code: 5014, category: DiagnosticCategory.Error, key: "Failed to parse file '{0}': {1}." },
-        Unknown_compiler_option_0: { code: 5023, category: DiagnosticCategory.Error, key: "Unknown compiler option '{0}'." },
-        Compiler_option_0_requires_a_value_of_type_1: { code: 5024, category: DiagnosticCategory.Error, key: "Compiler option '{0}' requires a value of type {1}." },
-        Could_not_write_file_0_Colon_1: { code: 5033, category: DiagnosticCategory.Error, key: "Could not write file '{0}': {1}" },
-        Option_project_cannot_be_mixed_with_source_files_on_a_command_line: { code: 5042, category: DiagnosticCategory.Error, key: "Option 'project' cannot be mixed with source files on a command line." },
-        Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher: { code: 5047, category: DiagnosticCategory.Error, key: "Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher." },
-        Option_inlineSources_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: { code: 5051, category: DiagnosticCategory.Error, key: "Option 'inlineSources' can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided." },
-        Option_0_cannot_be_specified_without_specifying_option_1: { code: 5052, category: DiagnosticCategory.Error, key: "Option '{0}' cannot be specified without specifying option '{1}'." },
-        Option_0_cannot_be_specified_with_option_1: { code: 5053, category: DiagnosticCategory.Error, key: "Option '{0}' cannot be specified with option '{1}'." },
-        A_tsconfig_json_file_is_already_defined_at_Colon_0: { code: 5053, category: DiagnosticCategory.Error, key: "A 'tsconfig.json' file is already defined at: '{0}'." },
-        Concatenate_and_emit_output_to_single_file: { code: 6001, category: DiagnosticCategory.Message, key: "Concatenate and emit output to single file." },
-        Generates_corresponding_d_ts_file: { code: 6002, category: DiagnosticCategory.Message, key: "Generates corresponding '.d.ts' file." },
-        Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: { code: 6003, category: DiagnosticCategory.Message, key: "Specifies the location where debugger should locate map files instead of generated locations." },
-        Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: { code: 6004, category: DiagnosticCategory.Message, key: "Specifies the location where debugger should locate TypeScript files instead of source locations." },
-        Watch_input_files: { code: 6005, category: DiagnosticCategory.Message, key: "Watch input files." },
-        Redirect_output_structure_to_the_directory: { code: 6006, category: DiagnosticCategory.Message, key: "Redirect output structure to the directory." },
-        Do_not_erase_const_enum_declarations_in_generated_code: { code: 6007, category: DiagnosticCategory.Message, key: "Do not erase const enum declarations in generated code." },
-        Do_not_emit_outputs_if_any_errors_were_reported: { code: 6008, category: DiagnosticCategory.Message, key: "Do not emit outputs if any errors were reported." },
-        Do_not_emit_comments_to_output: { code: 6009, category: DiagnosticCategory.Message, key: "Do not emit comments to output." },
-        Do_not_emit_outputs: { code: 6010, category: DiagnosticCategory.Message, key: "Do not emit outputs." },
-        Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental: { code: 6015, category: DiagnosticCategory.Message, key: "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES6' (experimental)" },
-        Specify_module_code_generation_Colon_commonjs_amd_system_or_umd: { code: 6016, category: DiagnosticCategory.Message, key: "Specify module code generation: 'commonjs', 'amd', 'system' or 'umd'" },
-        Print_this_message: { code: 6017, category: DiagnosticCategory.Message, key: "Print this message." },
-        Print_the_compiler_s_version: { code: 6019, category: DiagnosticCategory.Message, key: "Print the compiler's version." },
-        Compile_the_project_in_the_given_directory: { code: 6020, category: DiagnosticCategory.Message, key: "Compile the project in the given directory." },
-        Syntax_Colon_0: { code: 6023, category: DiagnosticCategory.Message, key: "Syntax: {0}" },
-        options: { code: 6024, category: DiagnosticCategory.Message, key: "options" },
-        file: { code: 6025, category: DiagnosticCategory.Message, key: "file" },
-        Examples_Colon_0: { code: 6026, category: DiagnosticCategory.Message, key: "Examples: {0}" },
-        Options_Colon: { code: 6027, category: DiagnosticCategory.Message, key: "Options:" },
-        Version_0: { code: 6029, category: DiagnosticCategory.Message, key: "Version {0}" },
-        Insert_command_line_options_and_files_from_a_file: { code: 6030, category: DiagnosticCategory.Message, key: "Insert command line options and files from a file." },
-        File_change_detected_Starting_incremental_compilation: { code: 6032, category: DiagnosticCategory.Message, key: "File change detected. Starting incremental compilation..." },
-        KIND: { code: 6034, category: DiagnosticCategory.Message, key: "KIND" },
-        FILE: { code: 6035, category: DiagnosticCategory.Message, key: "FILE" },
-        VERSION: { code: 6036, category: DiagnosticCategory.Message, key: "VERSION" },
-        LOCATION: { code: 6037, category: DiagnosticCategory.Message, key: "LOCATION" },
-        DIRECTORY: { code: 6038, category: DiagnosticCategory.Message, key: "DIRECTORY" },
-        Compilation_complete_Watching_for_file_changes: { code: 6042, category: DiagnosticCategory.Message, key: "Compilation complete. Watching for file changes." },
-        Generates_corresponding_map_file: { code: 6043, category: DiagnosticCategory.Message, key: "Generates corresponding '.map' file." },
-        Compiler_option_0_expects_an_argument: { code: 6044, category: DiagnosticCategory.Error, key: "Compiler option '{0}' expects an argument." },
-        Unterminated_quoted_string_in_response_file_0: { code: 6045, category: DiagnosticCategory.Error, key: "Unterminated quoted string in response file '{0}'." },
-        Argument_for_module_option_must_be_commonjs_amd_system_or_umd: { code: 6046, category: DiagnosticCategory.Error, key: "Argument for '--module' option must be 'commonjs', 'amd', 'system' or 'umd'." },
-        Argument_for_target_option_must_be_ES3_ES5_or_ES6: { code: 6047, category: DiagnosticCategory.Error, key: "Argument for '--target' option must be 'ES3', 'ES5', or 'ES6'." },
-        Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: { code: 6048, category: DiagnosticCategory.Error, key: "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'." },
-        Unsupported_locale_0: { code: 6049, category: DiagnosticCategory.Error, key: "Unsupported locale '{0}'." },
-        Unable_to_open_file_0: { code: 6050, category: DiagnosticCategory.Error, key: "Unable to open file '{0}'." },
-        Corrupted_locale_file_0: { code: 6051, category: DiagnosticCategory.Error, key: "Corrupted locale file {0}." },
-        Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: DiagnosticCategory.Message, key: "Raise error on expressions and declarations with an implied 'any' type." },
-        File_0_not_found: { code: 6053, category: DiagnosticCategory.Error, key: "File '{0}' not found." },
-        File_0_has_unsupported_extension_The_only_supported_extensions_are_1: { code: 6054, category: DiagnosticCategory.Error, key: "File '{0}' has unsupported extension. The only supported extensions are {1}." },
-        Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: DiagnosticCategory.Message, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." },
-        Do_not_emit_declarations_for_code_that_has_an_internal_annotation: { code: 6056, category: DiagnosticCategory.Message, key: "Do not emit declarations for code that has an '@internal' annotation." },
-        Specifies_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: { code: 6058, category: DiagnosticCategory.Message, key: "Specifies the root directory of input files. Use to control the output directory structure with --outDir." },
-        File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: { code: 6059, category: DiagnosticCategory.Error, key: "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files." },
-        Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." },
-        NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" },
-        Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." },
-        Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: DiagnosticCategory.Message, key: "Specify JSX code generation: 'preserve' or 'react'" },
-        Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for '--jsx' must be 'preserve' or 'react'." },
-        Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." },
-        Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: DiagnosticCategory.Message, key: "Enables experimental support for emitting type metadata for decorators." },
-        Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower: { code: 6067, category: DiagnosticCategory.Message, key: "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower." },
-        Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 async functions." },
-        Specifies_module_resolution_strategy_Colon_node_Node_or_classic_TypeScript_pre_1_6: { code: 6069, category: DiagnosticCategory.Message, key: "Specifies module resolution strategy: 'node' (Node) or 'classic' (TypeScript pre 1.6) ." },
-        Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: DiagnosticCategory.Message, key: "Initializes a TypeScript project and creates a tsconfig.json file." },
-        Successfully_created_a_tsconfig_json_file: { code: 6071, category: DiagnosticCategory.Message, key: "Successfully created a tsconfig.json file." },
-        Suppress_excess_property_checks_for_object_literals: { code: 6072, category: DiagnosticCategory.Message, key: "Suppress excess property checks for object literals." },
-        Variable_0_implicitly_has_an_1_type: { code: 7005, category: DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." },
-        Parameter_0_implicitly_has_an_1_type: { code: 7006, category: DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." },
-        Member_0_implicitly_has_an_1_type: { code: 7008, category: DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." },
-        new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: { code: 7009, category: DiagnosticCategory.Error, key: "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type." },
-        _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: { code: 7010, category: DiagnosticCategory.Error, key: "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type." },
-        Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: { code: 7011, category: DiagnosticCategory.Error, key: "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type." },
-        Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7013, category: DiagnosticCategory.Error, key: "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type." },
-        Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation: { code: 7016, category: DiagnosticCategory.Error, key: "Property '{0}' implicitly has type 'any', because its 'set' accessor lacks a type annotation." },
-        Index_signature_of_object_type_implicitly_has_an_any_type: { code: 7017, category: DiagnosticCategory.Error, key: "Index signature of object type implicitly has an 'any' type." },
-        Object_literal_s_property_0_implicitly_has_an_1_type: { code: 7018, category: DiagnosticCategory.Error, key: "Object literal's property '{0}' implicitly has an '{1}' type." },
-        Rest_parameter_0_implicitly_has_an_any_type: { code: 7019, category: DiagnosticCategory.Error, key: "Rest parameter '{0}' implicitly has an 'any[]' type." },
-        Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7020, category: DiagnosticCategory.Error, key: "Call signature, which lacks return-type annotation, implicitly has an 'any' return type." },
-        _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: DiagnosticCategory.Error, key: "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer." },
-        _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7023, category: DiagnosticCategory.Error, key: "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
-        Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: { code: 7024, category: DiagnosticCategory.Error, key: "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions." },
-        Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: DiagnosticCategory.Error, key: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." },
-        JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" },
-        You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." },
-        You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." },
-        import_can_only_be_used_in_a_ts_file: { code: 8002, category: DiagnosticCategory.Error, key: "'import ... =' can only be used in a .ts file." },
-        export_can_only_be_used_in_a_ts_file: { code: 8003, category: DiagnosticCategory.Error, key: "'export=' can only be used in a .ts file." },
-        type_parameter_declarations_can_only_be_used_in_a_ts_file: { code: 8004, category: DiagnosticCategory.Error, key: "'type parameter declarations' can only be used in a .ts file." },
-        implements_clauses_can_only_be_used_in_a_ts_file: { code: 8005, category: DiagnosticCategory.Error, key: "'implements clauses' can only be used in a .ts file." },
-        interface_declarations_can_only_be_used_in_a_ts_file: { code: 8006, category: DiagnosticCategory.Error, key: "'interface declarations' can only be used in a .ts file." },
-        module_declarations_can_only_be_used_in_a_ts_file: { code: 8007, category: DiagnosticCategory.Error, key: "'module declarations' can only be used in a .ts file." },
-        type_aliases_can_only_be_used_in_a_ts_file: { code: 8008, category: DiagnosticCategory.Error, key: "'type aliases' can only be used in a .ts file." },
-        _0_can_only_be_used_in_a_ts_file: { code: 8009, category: DiagnosticCategory.Error, key: "'{0}' can only be used in a .ts file." },
-        types_can_only_be_used_in_a_ts_file: { code: 8010, category: DiagnosticCategory.Error, key: "'types' can only be used in a .ts file." },
-        type_arguments_can_only_be_used_in_a_ts_file: { code: 8011, category: DiagnosticCategory.Error, key: "'type arguments' can only be used in a .ts file." },
-        parameter_modifiers_can_only_be_used_in_a_ts_file: { code: 8012, category: DiagnosticCategory.Error, key: "'parameter modifiers' can only be used in a .ts file." },
-        property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." },
-        enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." },
-        type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." },
-        decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." },
-        Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." },
-        class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." },
-        JSX_attributes_must_only_be_assigned_a_non_empty_expression: { code: 17000, category: DiagnosticCategory.Error, key: "JSX attributes must only be assigned a non-empty 'expression'." },
-        JSX_elements_cannot_have_multiple_attributes_with_the_same_name: { code: 17001, category: DiagnosticCategory.Error, key: "JSX elements cannot have multiple attributes with the same name." },
-        Expected_corresponding_JSX_closing_tag_for_0: { code: 17002, category: DiagnosticCategory.Error, key: "Expected corresponding JSX closing tag for '{0}'." },
-        JSX_attribute_expected: { code: 17003, category: DiagnosticCategory.Error, key: "JSX attribute expected." },
-        Cannot_use_JSX_unless_the_jsx_flag_is_provided: { code: 17004, category: DiagnosticCategory.Error, key: "Cannot use JSX unless the '--jsx' flag is provided." },
-        A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: { code: 17005, category: DiagnosticCategory.Error, key: "A constructor cannot contain a 'super' call when its class extends 'null'" },
-    };
-}

src/compiler/diagnosticMessages.json

@@ -195,7 +195,7 @@
         "category": "Error",
         "code": 1063
     },
-    "Ambient enum elements can only have integer literal initializers.": {
+    "In ambient enum declarations member initializer must be constant expression.": {
         "category": "Error",
         "code": 1066
     },
@@ -549,7 +549,7 @@
     },
     "An implementation cannot be declared in ambient contexts.": {
         "category": "Error",
-        "code": 1184
+        "code": 1183
     },
     "Modifiers cannot appear here.": {
         "category": "Error",
@@ -619,22 +619,18 @@
         "category": "Error",
         "code": 1200
     },
-    "Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"' or 'import d from \"mod\"' instead.": {
+    "Import assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead.": {
         "category": "Error",
         "code": 1202
     },
-    "Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead.": {
+    "Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead.": {
         "category": "Error",
         "code": 1203
     },
-    "Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher.": {
+    "Cannot compile modules into 'es2015' when targeting 'ES5' or lower.": {
         "category": "Error",
         "code": 1204
     },
-    "Decorators are only available when targeting ECMAScript 5 and higher.": {
-        "category": "Error",
-        "code": 1205
-    },
     "Decorators are not valid here.": {
         "category": "Error",
         "code": 1206
@@ -747,24 +743,6 @@
         "category": "Error",
         "code": 1235
     },
-    "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning.": {
-        "category": "Error",
-        "code": 1236
-    },
-
-
-    "'with' statements are not allowed in an async function block.": {
-        "category": "Error",
-        "code": 1300
-    },
-    "'await' expression is only allowed within an async function.": {
-        "category": "Error",
-        "code": 1308
-    },
-    "Async functions are only available when targeting ECMAScript 6 and higher.": {
-        "category": "Error",
-        "code": 1311
-    },
     "The return type of a property decorator function must be either 'void' or 'any'.": {
         "category": "Error",
         "code": 1236
@@ -805,6 +783,27 @@
         "category": "Error",
         "code": 1245
     },
+
+    "'with' statements are not allowed in an async function block.": {
+        "category": "Error",
+        "code": 1300
+    },
+    "'await' expression is only allowed within an async function.": {
+        "category": "Error",
+        "code": 1308
+    },
+    "Async functions are only available when targeting ECMAScript 6 and higher.": {
+        "category": "Error",
+        "code": 1311
+    },
+    "'=' can only be used in an object literal property inside a destructuring assignment.": {
+        "category": "Error",
+        "code": 1312
+    },
+    "The body of an 'if' statement cannot be the empty statement.": {
+        "category": "Error",
+        "code": 1313
+    },
     "Duplicate identifier '{0}'.": {
         "category": "Error",
         "code": 2300
@@ -1013,7 +1012,7 @@
         "category": "Error",
         "code": 2354
     },
-    "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.": {
+    "A function whose declared type is neither 'void' nor 'any' must return a value.": {
         "category": "Error",
         "code": 2355
     },
@@ -1097,7 +1096,7 @@
         "category": "Error",
         "code": 2377
     },
-    "A 'get' accessor must return a value or consist of a single 'throw' statement.": {
+    "A 'get' accessor must return a value.": {
         "category": "Error",
         "code": 2378
     },
@@ -1301,7 +1300,7 @@
         "category": "Error",
         "code": 2434
     },
-    "Ambient modules cannot be nested in other modules.": {
+    "Ambient modules cannot be nested in other modules or namespaces.": {
         "category": "Error",
         "code": 2435
     },
@@ -1625,10 +1624,6 @@
         "category": "Error",
         "code":2517
     },
-    "Only an ambient class can be merged with an interface.": {
-        "category": "Error",
-        "code": 2518
-    },
     "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions.": {
         "category": "Error",
         "code": 2520
@@ -1649,6 +1644,22 @@
         "category": "Error",
         "code": 2524
     },
+    "Initializer provides no value for this binding element and the binding element has no default value.": {
+        "category": "Error",
+        "code": 2525
+    },
+    "A 'this' type is available only in a non-static member of a class or interface.": {
+        "category": "Error",
+        "code": 2526
+    },
+    "The inferred type of '{0}' references an inaccessible 'this' type. A type annotation is necessary.": {
+        "category": "Error",
+        "code": 2527
+    },
+    "A module cannot have multiple default exports.": {
+        "category": "Error",
+        "code": 2528
+    },
     "JSX element attributes type '{0}' must be an object type.": {
         "category": "Error",
         "code": 2600
@@ -1701,7 +1712,18 @@
         "category": "Error",
         "code": 2653
     },
-
+    "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition.": {
+        "category": "Error",
+        "code": 2654
+    },
+    "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition.": {
+        "category": "Error",
+        "code": 2656
+    },
+    "JSX expressions must have one parent element": {
+        "category": "Error",
+        "code": 2657
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -1982,10 +2004,6 @@
         "category": "Error",
         "code": 4082
     },
-    "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.": {
-        "category": "Error",
-        "code": 4091
-    },
     "The current host does not support the '{0}' option.": {
         "category": "Error",
         "code": 5001
@@ -2022,7 +2040,7 @@
         "category": "Error",
         "code": 5042
     },
-    "Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher.": {
+    "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher.": {
         "category": "Error",
         "code": 5047
     },
@@ -2040,7 +2058,15 @@
     },
     "A 'tsconfig.json' file is already defined at: '{0}'.": {
         "category": "Error",
-        "code": 5053
+        "code": 5054
+    },
+    "Cannot write file '{0}' because it would overwrite input file.": {
+        "category": "Error",
+        "code": 5055
+    },
+    "Cannot write file '{0}' because it would be overwritten by multiple input files.": {
+        "category": "Error",
+        "code": 5056
     },
 
     "Concatenate and emit output to single file.": {
@@ -2083,11 +2109,11 @@
         "category": "Message",
         "code": 6010
     },
-    "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES6' (experimental)": {
-        "category": "Message",
-        "code": 6015
-    },
-    "Specify module code generation: 'commonjs', 'amd', 'system' or 'umd'": {
+  "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES2015' (experimental)": {
+    "category": "Message",
+    "code": 6015
+  },
+    "Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'": {
         "category": "Message",
         "code": 6016
     },
@@ -2171,14 +2197,14 @@
         "category": "Error",
         "code": 6045
     },
-    "Argument for '--module' option must be 'commonjs', 'amd', 'system' or 'umd'.": {
+    "Argument for '--module' option must be 'commonjs', 'amd', 'system', 'umd', or 'es2015'.": {
         "category": "Error",
         "code": 6046
     },
-    "Argument for '--target' option must be 'ES3', 'ES5', or 'ES6'.": {
-        "category": "Error",
-        "code": 6047
-    },
+  "Argument for '--target' option must be 'ES3', 'ES5', or 'ES2015'.": {
+    "category": "Error",
+    "code": 6047
+  },
     "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'.": {
         "category": "Error",
         "code": 6048
@@ -2235,14 +2261,11 @@
         "category": "Error",
         "code": 6062
     },
-    "Specify JSX code generation: 'preserve' or 'react'": {
-        "category": "Message",
-        "code": 6080
-    },
-    "Argument for '--jsx' must be 'preserve' or 'react'.": {
-        "category": "Message",
-        "code": 6081
+    "Argument for '--moduleResolution' option must be 'node' or 'classic'.": {
+        "category": "Error",
+        "code": 6063
     },
+
     "Enables experimental support for ES7 decorators.": {
         "category": "Message",
         "code": 6065
@@ -2251,15 +2274,11 @@
         "category": "Message",
         "code": 6066
     },
-    "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower.": {
-        "category": "Message",
-        "code": 6067
-    },
     "Enables experimental support for ES7 async functions.": {
         "category": "Message",
         "code": 6068
     },
-    "Specifies module resolution strategy: 'node' (Node) or 'classic' (TypeScript pre 1.6) .": {
+    "Specifies module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6).": {
         "category": "Message",
         "code": 6069
     },
@@ -2275,6 +2294,46 @@
         "category": "Message",
         "code": 6072
     },
+    "Stylize errors and messages using color and context. (experimental)": {
+        "category": "Message",
+        "code": 6073
+    },
+    "Do not report errors on unused labels.": {
+        "category": "Message",
+        "code": 6074
+    },
+    "Report error when not all code paths in function return a value.": {
+        "category": "Message",
+        "code": 6075
+    },
+    "Report errors for fallthrough cases in switch statement.": {
+        "category": "Message",
+        "code": 6076
+    },
+    "Do not report errors on unreachable code.": {
+        "category": "Message",
+        "code": 6077
+    },
+    "Disallow inconsistently-cased references to the same file.": {
+        "category": "Message",
+        "code": 6078
+    },
+    "Specify JSX code generation: 'preserve' or 'react'": {
+        "category": "Message",
+        "code": 6080
+    },
+    "Argument for '--jsx' must be 'preserve' or 'react'.": {
+        "category": "Message",
+        "code": 6081
+    },
+    "Only 'amd' and 'system' modules are supported alongside --{0}.": {
+        "category": "Error",
+        "code": 6082
+    },
+    "Allow javascript files to be compiled.": {
+        "category": "Message",
+        "code": 6083
+    },
 
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
@@ -2344,8 +2403,22 @@
         "category": "Error",
         "code": 7026
     },
-
-
+    "Unreachable code detected.": {
+        "category": "Error",
+        "code": 7027
+    },
+    "Unused label.": {
+        "category": "Error",
+        "code": 7028
+    },
+    "Fallthrough case in switch.": {
+        "category": "Error",
+        "code": 7029
+    },
+    "Not all code paths return a value.": {
+        "category": "Error",
+        "code": 7030
+    },    
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000
@@ -2446,5 +2519,13 @@
     "A constructor cannot contain a 'super' call when its class extends 'null'": {
       "category": "Error",
       "code": 17005
+    },
+    "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.": {
+      "category": "Error",
+      "code": 17006
+    },
+    "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses.": {
+      "category": "Error",
+      "code": 17007
     }
 }

src/compiler/sys.ts

@@ -8,7 +8,8 @@ namespace ts {
         write(s: string): void;
         readFile(path: string, encoding?: string): string;
         writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
-        watchFile?(path: string, callback: (path: string) => void): FileWatcher;
+        watchFile?(path: string, callback: (path: string, removed?: boolean) => void): FileWatcher;
+        watchDirectory?(path: string, callback: (path: string) => void, recursive?: boolean): FileWatcher;
         resolvePath(path: string): string;
         fileExists(path: string): boolean;
         directoryExists(path: string): boolean;
@@ -20,6 +21,12 @@ namespace ts {
         exit(exitCode?: number): void;
     }
 
+    interface WatchedFile {
+        fileName: string;
+        callback: (fileName: string, removed?: boolean) => void;
+        mtime: Date;
+    }
+
     export interface FileWatcher {
         close(): void;
     }
@@ -29,8 +36,8 @@ namespace ts {
     declare var process: any;
     declare var global: any;
     declare var __filename: string;
-    declare var Buffer: {  
-        new (str: string, encoding?: string): any;  
+    declare var Buffer: {
+        new (str: string, encoding?: string): any;
     };
 
     declare class Enumerator {
@@ -44,15 +51,15 @@ namespace ts {
 
         function getWScriptSystem(): System {
 
-            let fso = new ActiveXObject("Scripting.FileSystemObject");
+            const fso = new ActiveXObject("Scripting.FileSystemObject");
 
-            let fileStream = new ActiveXObject("ADODB.Stream");
+            const fileStream = new ActiveXObject("ADODB.Stream");
             fileStream.Type = 2 /*text*/;
 
-            let binaryStream = new ActiveXObject("ADODB.Stream");
+            const binaryStream = new ActiveXObject("ADODB.Stream");
             binaryStream.Type = 1 /*binary*/;
 
-            let args: string[] = [];
+            const args: string[] = [];
             for (let i = 0; i < WScript.Arguments.length; i++) {
                 args[i] = WScript.Arguments.Item(i);
             }
@@ -71,7 +78,7 @@ namespace ts {
                         // Load file and read the first two bytes into a string with no interpretation
                         fileStream.Charset = "x-ansi";
                         fileStream.LoadFromFile(fileName);
-                        let bom = fileStream.ReadText(2) || "";
+                        const bom = fileStream.ReadText(2) || "";
                         // Position must be at 0 before encoding can be changed
                         fileStream.Position = 0;
                         // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8
@@ -116,8 +123,8 @@ namespace ts {
                 return path.toLowerCase();
             }
 
-            function getNames(collection: any): string[]{
-                let result: string[] = [];
+            function getNames(collection: any): string[] {
+                const result: string[] = [];
                 for (let e = new Enumerator(collection); !e.atEnd(); e.moveNext()) {
                     result.push(e.item().Name);
                 }
@@ -125,22 +132,22 @@ namespace ts {
             }
 
             function readDirectory(path: string, extension?: string, exclude?: string[]): string[] {
-                let result: string[] = [];
+                const result: string[] = [];
                 exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
                 visitDirectory(path);
                 return result;
                 function visitDirectory(path: string) {
-                    let folder = fso.GetFolder(path || ".");
-                    let files = getNames(folder.files);
-                    for (let current of files) {
-                        let name = combinePaths(path, current);
+                    const folder = fso.GetFolder(path || ".");
+                    const files = getNames(folder.files);
+                    for (const current of files) {
+                        const name = combinePaths(path, current);
                         if ((!extension || fileExtensionIs(name, extension)) && !contains(exclude, getCanonicalPath(name))) {
                             result.push(name);
                         }
                     }
-                    let subfolders = getNames(folder.subfolders);
-                    for (let current of subfolders) {
-                        let name = combinePaths(path, current);
+                    const subfolders = getNames(folder.subfolders);
+                    for (const current of subfolders) {
+                        const name = combinePaths(path, current);
                         if (!contains(exclude, getCanonicalPath(name))) {
                             visitDirectory(name);
                         }
@@ -191,6 +198,104 @@ namespace ts {
             const _fs = require("fs");
             const _path = require("path");
             const _os = require("os");
+            const _tty = require("tty");
+
+            // average async stat takes about 30 microseconds
+            // set chunk size to do 30 files in < 1 millisecond
+            function createWatchedFileSet(interval = 2500, chunkSize = 30) {
+                let watchedFiles: WatchedFile[] = [];
+                let nextFileToCheck = 0;
+                let watchTimer: any;
+
+                function getModifiedTime(fileName: string): Date {
+                    return _fs.statSync(fileName).mtime;
+                }
+
+                function poll(checkedIndex: number) {
+                    const watchedFile = watchedFiles[checkedIndex];
+                    if (!watchedFile) {
+                        return;
+                    }
+
+                    _fs.stat(watchedFile.fileName, (err: any, stats: any) => {
+                        if (err) {
+                            watchedFile.callback(watchedFile.fileName);
+                        }
+                        else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
+                            watchedFile.mtime = getModifiedTime(watchedFile.fileName);
+                            watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0);
+                        }
+                    });
+                }
+
+                // this implementation uses polling and
+                // stat due to inconsistencies of fs.watch
+                // and efficiency of stat on modern filesystems
+                function startWatchTimer() {
+                    watchTimer = setInterval(() => {
+                        let count = 0;
+                        let nextToCheck = nextFileToCheck;
+                        let firstCheck = -1;
+                        while ((count < chunkSize) && (nextToCheck !== firstCheck)) {
+                            poll(nextToCheck);
+                            if (firstCheck < 0) {
+                                firstCheck = nextToCheck;
+                            }
+                            nextToCheck++;
+                            if (nextToCheck === watchedFiles.length) {
+                                nextToCheck = 0;
+                            }
+                            count++;
+                        }
+                        nextFileToCheck = nextToCheck;
+                    }, interval);
+                }
+
+                function addFile(fileName: string, callback: (fileName: string, removed?: boolean) => void): WatchedFile {
+                    const file: WatchedFile = {
+                        fileName,
+                        callback,
+                        mtime: getModifiedTime(fileName)
+                    };
+
+                    watchedFiles.push(file);
+                    if (watchedFiles.length === 1) {
+                        startWatchTimer();
+                    }
+                    return file;
+                }
+
+                function removeFile(file: WatchedFile) {
+                    watchedFiles = copyListRemovingItem(file, watchedFiles);
+                }
+
+                return {
+                    getModifiedTime: getModifiedTime,
+                    poll: poll,
+                    startWatchTimer: startWatchTimer,
+                    addFile: addFile,
+                    removeFile: removeFile
+                };
+            }
+
+            // REVIEW: for now this implementation uses polling.
+            // The advantage of polling is that it works reliably
+            // on all os and with network mounted files.
+            // For 90 referenced files, the average time to detect 
+            // changes is 2*msInterval (by default 5 seconds).
+            // The overhead of this is .04 percent (1/2500) with
+            // average pause of < 1 millisecond (and max
+            // pause less than 1.5 milliseconds); question is
+            // do we anticipate reference sets in the 100s and
+            // do we care about waiting 10-20 seconds to detect
+            // changes for large reference sets? If so, do we want
+            // to increase the chunk size or decrease the interval
+            // time dynamically to match the large reference set?
+            const watchedFileSet = createWatchedFileSet();
+
+            function isNode4OrLater(): Boolean {
+                return parseInt(process.version.charAt(1)) >= 4;
+            }
 
             const platform: string = _os.platform();
             // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
@@ -200,14 +305,14 @@ namespace ts {
                 if (!_fs.existsSync(fileName)) {
                     return undefined;
                 }
-                let buffer = _fs.readFileSync(fileName);
+                const buffer = _fs.readFileSync(fileName);
                 let len = buffer.length;
                 if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) {
                     // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js,
                     // flip all byte pairs and treat as little endian.
                     len &= ~1;
                     for (let i = 0; i < len; i += 2) {
-                        let temp = buffer[i];
+                        const temp = buffer[i];
                         buffer[i] = buffer[i + 1];
                         buffer[i + 1] = temp;
                     }
@@ -231,7 +336,17 @@ namespace ts {
                     data = "\uFEFF" + data;
                 }
 
-                _fs.writeFileSync(fileName, data, "utf8");
+                let fd: number;
+
+                try {
+                    fd = _fs.openSync(fileName, "w");
+                    _fs.writeSync(fd, data, undefined, "utf8");
+                }
+                finally {
+                    if (fd !== undefined) {
+                        _fs.closeSync(fd);
+                    }
+                }
             }
 
             function getCanonicalPath(path: string): string {
@@ -239,17 +354,17 @@ namespace ts {
             }
 
             function readDirectory(path: string, extension?: string, exclude?: string[]): string[] {
-                let result: string[] = [];
+                const result: string[] = [];
                 exclude = map(exclude, s => getCanonicalPath(combinePaths(path, s)));
                 visitDirectory(path);
                 return result;
                 function visitDirectory(path: string) {
-                    let files = _fs.readdirSync(path || ".").sort();
-                    let directories: string[] = [];
-                    for (let current of files) {
-                        let name = combinePaths(path, current);
+                    const files = _fs.readdirSync(path || ".").sort();
+                    const directories: string[] = [];
+                    for (const current of files) {
+                        const name = combinePaths(path, current);
                         if (!contains(exclude, getCanonicalPath(name))) {
-                            let stat = _fs.statSync(name);
+                            const stat = _fs.statSync(name);
                             if (stat.isFile()) {
                                 if (!extension || fileExtensionIs(name, extension)) {
                                     result.push(name);
@@ -260,7 +375,7 @@ namespace ts {
                             }
                         }
                     }
-                    for (let current of directories) {
+                    for (const current of directories) {
                         visitDirectory(current);
                     }
                 }
@@ -270,34 +385,42 @@ namespace ts {
                 args: process.argv.slice(2),
                 newLine: _os.EOL,
                 useCaseSensitiveFileNames: useCaseSensitiveFileNames,
-                write(s: string): void {  
-                    const buffer = new Buffer(s, "utf8");  
-                    let offset: number = 0;
-                    let toWrite: number = buffer.length;
-                    let written = 0;
-                    // 1 is a standard descriptor for stdout
-                    while ((written = _fs.writeSync(1, buffer, offset, toWrite)) < toWrite) {
-                        offset += written;
-                        toWrite -= written;
-                    }
-                },  
+                write(s: string): void {
+                    process.stdout.write(s);
+                },
                 readFile,
                 writeFile,
                 watchFile: (fileName, callback) => {
-                    // watchFile polls a file every 250ms, picking up file notifications.
-                    _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);
-
-                    return {
-                        close() { _fs.unwatchFile(fileName, fileChanged); }
-                    };
-
-                    function fileChanged(curr: any, prev: any) {
-                        if (+curr.mtime <= +prev.mtime) {
-                            return;
-                        }
-
-                        callback(fileName);
+                    // Node 4.0 stablized the `fs.watch` function on Windows which avoids polling
+                    // and is more efficient than `fs.watchFile` (ref: https://github.com/nodejs/node/pull/2649
+                    // and https://github.com/Microsoft/TypeScript/issues/4643), therefore
+                    // if the current node.js version is newer than 4, use `fs.watch` instead.
+                    if (isNode4OrLater()) {
+                        // Note: in node the callback of fs.watch is given only the relative file name as a parameter
+                        return _fs.watch(fileName, (eventName: string, relativeFileName: string) => callback(fileName));
                     }
+
+                    const watchedFile = watchedFileSet.addFile(fileName, callback);
+                    return {
+                        close: () => watchedFileSet.removeFile(watchedFile)
+                    };
+                },
+                watchDirectory: (path, callback, recursive) => {
+                    // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows 
+                    // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643)
+                    return _fs.watch(
+                        path,
+                        { persistent: true, recursive: !!recursive },
+                        (eventName: string, relativeFileName: string) => {
+                            // In watchDirectory we only care about adding and removing files (when event name is
+                            // "rename"); changes made within files are handled by corresponding fileWatchers (when
+                            // event name is "change")
+                            if (eventName === "rename") {
+                                // When deleting a file, the passed baseFileName is null
+                                callback(!relativeFileName ? relativeFileName : normalizePath(ts.combinePaths(path, relativeFileName)));
+                            };
+                        }
+                    );
                 },
                 resolvePath: function (path: string): string {
                     return _path.resolve(path);

src/compiler/tsc.ts

@@ -6,20 +6,28 @@ namespace ts {
         fileWatcher?: FileWatcher;
     }
 
+    let reportDiagnostic = reportDiagnosticSimply;
+
+    function reportDiagnostics(diagnostics: Diagnostic[], host: CompilerHost): void {
+        for (const diagnostic of diagnostics) {
+            reportDiagnostic(diagnostic, host);
+        }
+    }
+
     /**
      * Checks to see if the locale is in the appropriate format,
      * and if it is, attempts to set the appropriate language.
      */
     function validateLocaleAndSetLanguage(locale: string, errors: Diagnostic[]): boolean {
-        let matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase());
+        const matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase());
 
         if (!matchResult) {
             errors.push(createCompilerDiagnostic(Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp"));
             return false;
         }
 
-        let language = matchResult[1];
-        let territory = matchResult[3];
+        const language = matchResult[1];
+        const territory = matchResult[3];
 
         // First try the entire locale, then fall back to just language if that's all we have.
         if (!trySetLanguageAndTerritory(language, territory, errors) &&
@@ -33,8 +41,8 @@ namespace ts {
     }
 
     function trySetLanguageAndTerritory(language: string, territory: string, errors: Diagnostic[]): boolean {
-        let compilerFilePath = normalizePath(sys.getExecutingFilePath());
-        let containingDirectoryPath = getDirectoryPath(compilerFilePath);
+        const compilerFilePath = normalizePath(sys.getExecutingFilePath());
+        const containingDirectoryPath = getDirectoryPath(compilerFilePath);
 
         let filePath = combinePaths(containingDirectoryPath, language);
 
@@ -77,29 +85,128 @@ namespace ts {
     }
 
     function getDiagnosticText(message: DiagnosticMessage, ...args: any[]): string {
-        let diagnostic = createCompilerDiagnostic.apply(undefined, arguments);
+        const diagnostic = createCompilerDiagnostic.apply(undefined, arguments);
         return <string>diagnostic.messageText;
     }
 
-    function reportDiagnostic(diagnostic: Diagnostic) {
+    function getRelativeFileName(fileName: string, host: CompilerHost): string {
+        return host ? convertToRelativePath(fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName)) : fileName;
+    }
+
+    function reportDiagnosticSimply(diagnostic: Diagnostic, host: CompilerHost): void {
         let output = "";
 
         if (diagnostic.file) {
-            let loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
-
-            output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `;
+            const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            const relativeFileName = getRelativeFileName(diagnostic.file.fileName, host);
+            output += `${ relativeFileName }(${ line + 1 },${ character + 1 }): `;
         }
 
-        let category = DiagnosticCategory[diagnostic.category].toLowerCase();
+        const category = DiagnosticCategory[diagnostic.category].toLowerCase();
         output += `${ category } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
 
         sys.write(output);
     }
 
-    function reportDiagnostics(diagnostics: Diagnostic[]) {
-        for (let i = 0; i < diagnostics.length; i++) {
-            reportDiagnostic(diagnostics[i]);
+
+    const redForegroundEscapeSequence = "\u001b[91m";
+    const yellowForegroundEscapeSequence = "\u001b[93m";
+    const blueForegroundEscapeSequence = "\u001b[93m";
+    const gutterStyleSequence = "\u001b[100;30m";
+    const gutterSeparator = " ";
+    const resetEscapeSequence = "\u001b[0m";
+    const elipsis = "...";
+    const categoryFormatMap: Map<string> = {
+        [DiagnosticCategory.Warning]: yellowForegroundEscapeSequence,
+        [DiagnosticCategory.Error]: redForegroundEscapeSequence,
+        [DiagnosticCategory.Message]: blueForegroundEscapeSequence,
+    };
+
+    function formatAndReset(text: string, formatStyle: string) {
+        return formatStyle + text + resetEscapeSequence;
+    }
+
+    function reportDiagnosticWithColorAndContext(diagnostic: Diagnostic, host: CompilerHost): void {
+        let output = "";
+
+        if (diagnostic.file) {
+            const { start, length, file } = diagnostic;
+            const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start);
+            const { line: lastLine, character: lastLineChar } = getLineAndCharacterOfPosition(file, start + length);
+            const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;
+            const relativeFileName = getRelativeFileName(file.fileName, host);
+
+            const hasMoreThanFiveLines = (lastLine - firstLine) >= 4;
+            let gutterWidth = (lastLine + 1 + "").length;
+            if (hasMoreThanFiveLines) {
+                gutterWidth = Math.max(elipsis.length, gutterWidth);
+            }
+
+            output += sys.newLine;
+            for (let i = firstLine; i <= lastLine; i++) {
+                // If the error spans over 5 lines, we'll only show the first 2 and last 2 lines,
+                // so we'll skip ahead to the second-to-last line.
+                if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
+                    output += formatAndReset(padLeft(elipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + sys.newLine;
+                    i = lastLine - 1;
+                }
+
+                const lineStart = getPositionOfLineAndCharacter(file, i, 0);
+                const lineEnd = i < lastLineInFile ? getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;
+                let lineContent = file.text.slice(lineStart, lineEnd);
+                lineContent = lineContent.replace(/\s+$/g, "");  // trim from end
+                lineContent = lineContent.replace("\t", " ");    // convert tabs to single spaces
+
+                // Output the gutter and the actual contents of the line.
+                output += formatAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;
+                output += lineContent + sys.newLine;
+
+                // Output the gutter and the error span for the line using tildes.
+                output += formatAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;
+                output += redForegroundEscapeSequence;
+                if (i === firstLine) {
+                    // If we're on the last line, then limit it to the last character of the last line.
+                    // Otherwise, we'll just squiggle the rest of the line, giving 'slice' no end position.
+                    const lastCharForLine = i === lastLine ? lastLineChar : undefined;
+
+                    output += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
+                    output += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");
+                }
+                else if (i === lastLine) {
+                    output += lineContent.slice(0, lastLineChar).replace(/./g, "~");
+                }
+                else {
+                    // Squiggle the entire line.
+                    output += lineContent.replace(/./g, "~");
+                }
+                output += resetEscapeSequence;
+
+                output += sys.newLine;
+            }
+
+            output += sys.newLine;
+            output += `${ relativeFileName }(${ firstLine + 1 },${ firstLineChar + 1 }): `;
         }
+
+        const categoryColor = categoryFormatMap[diagnostic.category];
+        const category = DiagnosticCategory[diagnostic.category].toLowerCase();
+        output += `${ formatAndReset(category, categoryColor) } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }`;
+        output += sys.newLine + sys.newLine;
+
+        sys.write(output);
+    }
+
+    function reportWatchDiagnostic(diagnostic: Diagnostic) {
+        let output = new Date().toLocaleTimeString() + " - ";
+
+        if (diagnostic.file) {
+            const loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+            output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `;
+        }
+
+        output += `${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
+
+        sys.write(output);
     }
 
     function padLeft(s: string, length: number) {
@@ -134,19 +241,27 @@ namespace ts {
     }
 
     export function executeCommandLine(args: string[]): void {
-        let commandLine = parseCommandLine(args);
-        let configFileName: string;                 // Configuration file name (if any)
-        let configFileWatcher: FileWatcher;         // Configuration file watcher
-        let cachedProgram: Program;                 // Program cached from last compilation
-        let rootFileNames: string[];                // Root fileNames for compilation
-        let compilerOptions: CompilerOptions;       // Compiler options for compilation
-        let compilerHost: CompilerHost;             // Compiler host
-        let hostGetSourceFile: typeof compilerHost.getSourceFile;  // getSourceFile method from default host
-        let timerHandle: number;                    // Handle for 0.25s wait timer
+        const commandLine = parseCommandLine(args);
+        let configFileName: string;                                 // Configuration file name (if any)
+        let cachedConfigFileText: string;                           // Cached configuration file text, used for reparsing (if any)
+        let configFileWatcher: FileWatcher;                         // Configuration file watcher
+        let directoryWatcher: FileWatcher;                          // Directory watcher to monitor source file addition/removal
+        let cachedProgram: Program;                                 // Program cached from last compilation
+        let rootFileNames: string[];                                // Root fileNames for compilation
+        let compilerOptions: CompilerOptions;                       // Compiler options for compilation
+        let compilerHost: CompilerHost;                             // Compiler host
+        let hostGetSourceFile: typeof compilerHost.getSourceFile;   // getSourceFile method from default host
+        let timerHandleForRecompilation: number;                    // Handle for 0.25s wait timer to trigger recompilation
+        let timerHandleForDirectoryChanges: number;                 // Handle for 0.25s wait timer to trigger directory change handler
+
+        // This map stores and reuses results of fileExists check that happen inside 'createProgram'
+        // This allows to save time in module resolution heavy scenarios when existence of the same file might be checked multiple times.
+        let cachedExistingFiles: Map<boolean>;
+        let hostFileExists: typeof compilerHost.fileExists;
 
         if (commandLine.options.locale) {
             if (!isJSONSupported()) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"));
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"), /* compilerHost */ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             validateLocaleAndSetLanguage(commandLine.options.locale, commandLine.errors);
@@ -155,7 +270,7 @@ namespace ts {
         // If there are any errors due to command line parsing and/or
         // setting up localization, report them and quit.
         if (commandLine.errors.length > 0) {
-            reportDiagnostics(commandLine.errors);
+            reportDiagnostics(commandLine.errors, compilerHost);
             return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
         }
 
@@ -165,7 +280,7 @@ namespace ts {
         }
 
         if (commandLine.options.version) {
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Version_0, ts.version));
+            printVersion();
             return sys.exit(ExitStatus.Success);
         }
 
@@ -177,18 +292,18 @@ namespace ts {
 
         if (commandLine.options.project) {
             if (!isJSONSupported()) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--project"));
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--project"), /* compilerHost */ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             configFileName = normalizePath(combinePaths(commandLine.options.project, "tsconfig.json"));
             if (commandLine.fileNames.length !== 0) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line));
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line), /* compilerHost */ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
         }
         else if (commandLine.fileNames.length === 0 && isJSONSupported()) {
-            let searchPath = normalizePath(sys.getCurrentDirectory());
-            configFileName = findConfigFile(searchPath);
+            const searchPath = normalizePath(sys.getCurrentDirectory());
+            configFileName = findConfigFile(searchPath, sys.fileExists);
         }
 
         if (commandLine.fileNames.length === 0 && !configFileName) {
@@ -200,36 +315,68 @@ namespace ts {
         // Firefox has Object.prototype.watch
         if (commandLine.options.watch && commandLine.options.hasOwnProperty("watch")) {
             if (!sys.watchFile) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"));
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"), /* compilerHost */ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             if (configFileName) {
                 configFileWatcher = sys.watchFile(configFileName, configFileChanged);
             }
+            if (sys.watchDirectory && configFileName) {
+                const directory = ts.getDirectoryPath(configFileName);
+                directoryWatcher = sys.watchDirectory(
+                    // When the configFileName is just "tsconfig.json", the watched directory should be 
+                    // the current direcotry; if there is a given "project" parameter, then the configFileName
+                    // is an absolute file name.
+                    directory == "" ? "." : directory,
+                    watchedDirectoryChanged, /*recursive*/ true);
+            }
         }
 
         performCompilation();
 
+        function parseConfigFile(): ParsedCommandLine {
+            if (!cachedConfigFileText) {
+                try {
+                    cachedConfigFileText = sys.readFile(configFileName);
+                }
+                catch (e) {
+                    const error = createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, configFileName, e.message);
+                    reportWatchDiagnostic(error);
+                    sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                    return;
+                }
+            }
+            if (!cachedConfigFileText) {
+                const error = createCompilerDiagnostic(Diagnostics.File_0_not_found, configFileName);
+                reportDiagnostics([error], /* compilerHost */ undefined);
+                sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                return;
+            }
+
+            const result = parseConfigFileTextToJson(configFileName, cachedConfigFileText);
+            const configObject = result.config;
+            if (!configObject) {
+                reportDiagnostics([result.error], /* compilerHost */ undefined);
+                sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                return;
+            }
+            const configParseResult = parseJsonConfigFileContent(configObject, sys, getDirectoryPath(configFileName), commandLine.options);
+            if (configParseResult.errors.length > 0) {
+                reportDiagnostics(configParseResult.errors, /* compilerHost */ undefined);
+                sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
+                return;
+            }
+            return configParseResult;
+        }
+
         // Invoked to perform initial compilation or re-compilation in watch mode
         function performCompilation() {
 
             if (!cachedProgram) {
                 if (configFileName) {
-
-                    let result = readConfigFile(configFileName, sys.readFile);
-                    if (result.error) {
-                        reportDiagnostic(result.error);
-                        return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
-                    }
-
-                    let configObject = result.config;
-                    let configParseResult = parseConfigFile(configObject, sys, getDirectoryPath(configFileName));
-                    if (configParseResult.errors.length > 0) {
-                        reportDiagnostics(configParseResult.errors);
-                        return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
-                    }
+                    const configParseResult = parseConfigFile();
                     rootFileNames = configParseResult.fileNames;
-                    compilerOptions = extend(commandLine.options, configParseResult.options);
+                    compilerOptions = configParseResult.options;
                 }
                 else {
                     rootFileNames = commandLine.fileNames;
@@ -238,32 +385,49 @@ namespace ts {
                 compilerHost = createCompilerHost(compilerOptions);
                 hostGetSourceFile = compilerHost.getSourceFile;
                 compilerHost.getSourceFile = getSourceFile;
+
+                hostFileExists = compilerHost.fileExists;
+                compilerHost.fileExists = cachedFileExists;
             }
 
-            let compileResult = compile(rootFileNames, compilerOptions, compilerHost);
+            if (compilerOptions.pretty) {
+                reportDiagnostic = reportDiagnosticWithColorAndContext;
+            }
+
+            // reset the cache of existing files
+            cachedExistingFiles = {};
+
+            const compileResult = compile(rootFileNames, compilerOptions, compilerHost);
 
             if (!compilerOptions.watch) {
                 return sys.exit(compileResult.exitStatus);
             }
 
             setCachedProgram(compileResult.program);
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Compilation_complete_Watching_for_file_changes));
+            reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.Compilation_complete_Watching_for_file_changes));
+        }
+
+        function cachedFileExists(fileName: string): boolean {
+            if (hasProperty(cachedExistingFiles, fileName)) {
+                return cachedExistingFiles[fileName];
+            }
+            return cachedExistingFiles[fileName] = hostFileExists(fileName);
         }
 
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
             // Return existing SourceFile object if one is available
             if (cachedProgram) {
-                let sourceFile = cachedProgram.getSourceFile(fileName);
+                const sourceFile = cachedProgram.getSourceFile(fileName);
                 // A modified source file has no watcher and should not be reused
                 if (sourceFile && sourceFile.fileWatcher) {
                     return sourceFile;
                 }
             }
             // Use default host function
-            let sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
+            const sourceFile = hostGetSourceFile(fileName, languageVersion, onError);
             if (sourceFile && compilerOptions.watch) {
                 // Attach a file watcher
-                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, () => sourceFileChanged(sourceFile));
+                sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (fileName: string, removed?: boolean) => sourceFileChanged(sourceFile, removed));
             }
             return sourceFile;
         }
@@ -271,7 +435,7 @@ namespace ts {
         // Change cached program to the given program
         function setCachedProgram(program: Program) {
             if (cachedProgram) {
-                let newSourceFiles = program ? program.getSourceFiles() : undefined;
+                const newSourceFiles = program ? program.getSourceFiles() : undefined;
                 forEach(cachedProgram.getSourceFiles(), sourceFile => {
                     if (!(newSourceFiles && contains(newSourceFiles, sourceFile))) {
                         if (sourceFile.fileWatcher) {
@@ -285,31 +449,65 @@ namespace ts {
         }
 
         // If a source file changes, mark it as unwatched and start the recompilation timer
-        function sourceFileChanged(sourceFile: SourceFile) {
+        function sourceFileChanged(sourceFile: SourceFile, removed?: boolean) {
             sourceFile.fileWatcher.close();
             sourceFile.fileWatcher = undefined;
-            startTimer();
+            if (removed) {
+                const index = rootFileNames.indexOf(sourceFile.fileName);
+                if (index >= 0) {
+                    rootFileNames.splice(index, 1);
+                }
+            }
+            startTimerForRecompilation();
         }
 
         // If the configuration file changes, forget cached program and start the recompilation timer
         function configFileChanged() {
             setCachedProgram(undefined);
-            startTimer();
+            cachedConfigFileText = undefined;
+            startTimerForRecompilation();
+        }
+
+        function watchedDirectoryChanged(fileName: string) {
+            if (fileName && !ts.isSupportedSourceFileName(fileName, commandLine.options)) {
+                return;
+            }
+
+            startTimerForHandlingDirectoryChanges();
+        }
+
+        function startTimerForHandlingDirectoryChanges() {
+            if (timerHandleForDirectoryChanges) {
+                clearTimeout(timerHandleForDirectoryChanges);
+            }
+            timerHandleForDirectoryChanges = setTimeout(directoryChangeHandler, 250);
+        }
+
+        function directoryChangeHandler() {
+            const parsedCommandLine = parseConfigFile();
+            const newFileNames = ts.map(parsedCommandLine.fileNames, compilerHost.getCanonicalFileName);
+            const canonicalRootFileNames = ts.map(rootFileNames, compilerHost.getCanonicalFileName);
+
+            // We check if the project file list has changed. If so, we just throw away the old program and start fresh.
+            if (!arrayIsEqualTo(newFileNames && newFileNames.sort(), canonicalRootFileNames && canonicalRootFileNames.sort())) {
+                setCachedProgram(undefined);
+                startTimerForRecompilation();
+            }
         }
 
         // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives batch
         // operations (such as saving all modified files in an editor) a chance to complete before we kick
         // off a new compilation.
-        function startTimer() {
-            if (timerHandle) {
-                clearTimeout(timerHandle);
+        function startTimerForRecompilation() {
+            if (timerHandleForRecompilation) {
+                clearTimeout(timerHandleForRecompilation);
             }
-            timerHandle = setTimeout(recompile, 250);
+            timerHandleForRecompilation = setTimeout(recompile, 250);
         }
 
         function recompile() {
-            timerHandle = undefined;
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation));
+            timerHandleForRecompilation = undefined;
+            reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation));
             performCompilation();
         }
     }
@@ -322,8 +520,8 @@ namespace ts {
         checkTime = 0;
         emitTime = 0;
 
-        let program = createProgram(fileNames, compilerOptions, compilerHost);
-        let exitStatus = compileProgram();
+        const program = createProgram(fileNames, compilerOptions, compilerHost);
+        const exitStatus = compileProgram();
 
         if (compilerOptions.listFiles) {
             forEach(program.getSourceFiles(), file => {
@@ -332,7 +530,7 @@ namespace ts {
         }
 
         if (compilerOptions.diagnostics) {
-            let memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
+            const memoryUsed = sys.getMemoryUsage ? sys.getMemoryUsage() : -1;
             reportCountStatistic("Files", program.getSourceFiles().length);
             reportCountStatistic("Lines", countLines(program));
             reportCountStatistic("Nodes", program.getNodeCount());
@@ -361,7 +559,7 @@ namespace ts {
 
         function compileProgram(): ExitStatus {
             let diagnostics: Diagnostic[];
-            
+
             // First get and report any syntactic errors.
             diagnostics = program.getSyntacticDiagnostics();
 
@@ -375,7 +573,7 @@ namespace ts {
                 }
             }
 
-            reportDiagnostics(diagnostics);
+            reportDiagnostics(diagnostics, compilerHost);
 
             // If the user doesn't want us to emit, then we're done at this point.
             if (compilerOptions.noEmit) {
@@ -385,8 +583,8 @@ namespace ts {
             }
 
             // Otherwise, emit and report any errors we ran into.
-            let emitOutput = program.emit();
-            reportDiagnostics(emitOutput.diagnostics);
+            const emitOutput = program.emit();
+            reportDiagnostics(emitOutput.diagnostics, compilerHost);
 
             // If the emitter didn't emit anything, then pass that value along.
             if (emitOutput.emitSkipped) {
@@ -411,8 +609,8 @@ namespace ts {
         let output = "";
 
         // We want to align our "syntax" and "examples" commands to a certain margin.
-        let syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length;
-        let examplesLength = getDiagnosticText(Diagnostics.Examples_Colon_0, "").length;
+        const syntaxLength = getDiagnosticText(Diagnostics.Syntax_Colon_0, "").length;
+        const examplesLength = getDiagnosticText(Diagnostics.Examples_Colon_0, "").length;
         let marginLength = Math.max(syntaxLength, examplesLength);
 
         // Build up the syntactic skeleton.
@@ -423,7 +621,7 @@ namespace ts {
         output += sys.newLine + sys.newLine;
 
         // Build up the list of examples.
-        let padding = makePadding(marginLength);
+        const padding = makePadding(marginLength);
         output += getDiagnosticText(Diagnostics.Examples_Colon_0, makePadding(marginLength - examplesLength) + "tsc hello.ts") + sys.newLine;
         output += padding + "tsc --out file.js file.ts" + sys.newLine;
         output += padding + "tsc @args.txt" + sys.newLine;
@@ -432,17 +630,17 @@ namespace ts {
         output += getDiagnosticText(Diagnostics.Options_Colon) + sys.newLine;
 
         // Sort our options by their names, (e.g. "--noImplicitAny" comes before "--watch")
-        let optsList = filter(optionDeclarations.slice(), v => !v.experimental);
+        const optsList = filter(optionDeclarations.slice(), v => !v.experimental);
         optsList.sort((a, b) => compareValues<string>(a.name.toLowerCase(), b.name.toLowerCase()));
 
         // We want our descriptions to align at the same column in our output,
         // so we keep track of the longest option usage string.
         marginLength = 0;
-        let usageColumn: string[] = []; // Things like "-d, --declaration" go in here.
-        let descriptionColumn: string[] = [];
+        const usageColumn: string[] = []; // Things like "-d, --declaration" go in here.
+        const descriptionColumn: string[] = [];
 
         for (let i = 0; i < optsList.length; i++) {
-            let option = optsList[i];
+            const option = optsList[i];
 
             // If an option lacks a description,
             // it is not officially supported.
@@ -468,15 +666,15 @@ namespace ts {
         }
 
         // Special case that can't fit in the loop.
-        let usageText = " @<" + getDiagnosticText(Diagnostics.file) + ">";
+        const usageText = " @<" + getDiagnosticText(Diagnostics.file) + ">";
         usageColumn.push(usageText);
         descriptionColumn.push(getDiagnosticText(Diagnostics.Insert_command_line_options_and_files_from_a_file));
         marginLength = Math.max(usageText.length, marginLength);
 
         // Print out each row, aligning all the descriptions on the same column.
         for (let i = 0; i < usageColumn.length; i++) {
-            let usage = usageColumn[i];
-            let description = descriptionColumn[i];
+            const usage = usageColumn[i];
+            const description = descriptionColumn[i];
             output += usage + makePadding(marginLength - usage.length + 2) + description + sys.newLine;
         }
 
@@ -496,14 +694,14 @@ namespace ts {
     }
 
     function writeConfigFile(options: CompilerOptions, fileNames: string[]) {
-        let currentDirectory = sys.getCurrentDirectory();
-        let file = combinePaths(currentDirectory, 'tsconfig.json');
+        const currentDirectory = sys.getCurrentDirectory();
+        const file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
         if (sys.fileExists(file)) {
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file));
+            reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), /* compilerHost */ undefined);
         }
         else {
-            let compilerOptions = extend(options, defaultInitCompilerOptions);
-            let configurations: any = {
+            const compilerOptions = extend(options, defaultInitCompilerOptions);
+            const configurations: any = {
                 compilerOptions: serializeCompilerOptions(compilerOptions),
                 exclude: ["node_modules"]
             };
@@ -514,18 +712,18 @@ namespace ts {
             }
 
             sys.writeFile(file, JSON.stringify(configurations, undefined, 4));
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Successfully_created_a_tsconfig_json_file));
+            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Successfully_created_a_tsconfig_json_file), /* compilerHost */ undefined);
         }
 
         return;
 
-        function serializeCompilerOptions(options: CompilerOptions): Map<string|number|boolean> {
-            let result: Map<string|number|boolean> = {};
-            let optionsNameMap = getOptionNameMap().optionNameMap;
+        function serializeCompilerOptions(options: CompilerOptions): Map<string | number | boolean> {
+            const result: Map<string | number | boolean> = {};
+            const optionsNameMap = getOptionNameMap().optionNameMap;
 
-            for (let name in options) {
+            for (const name in options) {
                 if (hasProperty(options, name)) {
-                    let value = options[name];
+                    const value = options[name];
                     switch (name) {
                         case "init":
                         case "watch":
@@ -542,8 +740,8 @@ namespace ts {
                                 }
                                 else {
                                     // Enum
-                                    let typeMap = <Map<number>>optionDefinition.type;
-                                    for (let key in typeMap) {
+                                    const typeMap = <Map<number>>optionDefinition.type;
+                                    for (const key in typeMap) {
                                         if (hasProperty(typeMap, key)) {
                                             if (typeMap[key] === value)
                                                 result[name] = key;

src/compiler/tsconfig.json

@@ -11,6 +11,7 @@
         "core.ts",
         "sys.ts",
         "types.ts",
+        "diagnosticInformationMap.generated.ts",
         "scanner.ts",
         "parser.ts",
         "utilities.ts",
@@ -19,7 +20,6 @@
         "emitter.ts",
         "program.ts",
         "commandLineParser.ts",
-        "tsc.ts",
-        "diagnosticInformationMap.generated.ts"
+        "tsc.ts"
     ]
 }

src/harness/compilerRunner.ts

@@ -1,6 +1,7 @@
 /// <reference path="harness.ts" />
 /// <reference path="runnerbase.ts" />
 /// <reference path="typeWriter.ts" />
+/* tslint:disable:no-null */
 
 const enum CompilerTestType {
     Conformance,
@@ -32,118 +33,86 @@ class CompilerBaselineRunner extends RunnerBase {
         }
         else if (testType === CompilerTestType.Test262) {
             this.testSuiteName = "test262";
-        } else {
+        }
+        else {
             this.testSuiteName = "compiler"; // default to this for historical reasons
         }
         this.basePath += "/" + this.testSuiteName;
     }
 
+    private makeUnitName(name: string, root: string) {
+        return ts.isRootedDiskPath(name) ? name : ts.combinePaths(root, name);
+    };
+
     public checkTestCodeOutput(fileName: string) {
         describe("compiler tests for " + fileName, () => {
             // Mocha holds onto the closure environment of the describe callback even after the test is done.
             // Everything declared here should be cleared out in the "after" callback.
             let justName: string;
-            let content: string;
-            let testCaseContent: { settings: Harness.TestCaseParser.CompilerSetting[]; testUnitData: Harness.TestCaseParser.TestUnitData[]; };
-
-            let units: Harness.TestCaseParser.TestUnitData[];
-            let tcSettings: Harness.TestCaseParser.CompilerSetting[];
 
             let lastUnit: Harness.TestCaseParser.TestUnitData;
-            let rootDir: string;
+            let harnessSettings: Harness.TestCaseParser.CompilerSettings;
+            let hasNonDtsFiles: boolean;
 
             let result: Harness.Compiler.CompilerResult;
-            let program: ts.Program;
             let options: ts.CompilerOptions;
             // equivalent to the files that will be passed on the command line
-            let toBeCompiled: { unitName: string; content: string }[];
+            let toBeCompiled: Harness.Compiler.TestFile[];
             // equivalent to other files on the file system not directly passed to the compiler (ie things that are referenced by other files)
-            let otherFiles: { unitName: string; content: string }[];
-            let harnessCompiler: Harness.Compiler.HarnessCompiler;
-
-            let createNewInstance = false;
+            let otherFiles: Harness.Compiler.TestFile[];
 
             before(() => {
                 justName = fileName.replace(/^.*[\\\/]/, ""); // strips the fileName from the path.
-                content = Harness.IO.readFile(fileName);
-                testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);
-                units = testCaseContent.testUnitData;
-                tcSettings = testCaseContent.settings;
-                createNewInstance = false;
+                const content = Harness.IO.readFile(fileName);
+                const testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);
+                const units = testCaseContent.testUnitData;
+                harnessSettings = testCaseContent.settings;
                 lastUnit = units[units.length - 1];
-                rootDir = lastUnit.originalFilePath.indexOf("conformance") === -1 ? "tests/cases/compiler/" : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf("/")) + "/";
-                harnessCompiler = Harness.Compiler.getCompiler();
+                hasNonDtsFiles = ts.forEach(units, unit => !ts.fileExtensionIs(unit.name, ".d.ts"));
+                const rootDir = lastUnit.originalFilePath.indexOf("conformance") === -1 ? "tests/cases/compiler/" : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf("/")) + "/";
                 // We need to assemble the list of input files for the compiler and other related files on the 'filesystem' (ie in a multi-file test)
                 // If the last file in a test uses require or a triple slash reference we'll assume all other files will be brought in via references,
                 // otherwise, assume all files are just meant to be in the same compilation session without explicit references to one another.
                 toBeCompiled = [];
                 otherFiles = [];
                 if (/require\(/.test(lastUnit.content) || /reference\spath/.test(lastUnit.content)) {
-                    toBeCompiled.push({ unitName: rootDir + lastUnit.name, content: lastUnit.content });
+                    toBeCompiled.push({ unitName: this.makeUnitName(lastUnit.name, rootDir), content: lastUnit.content });
                     units.forEach(unit => {
                         if (unit.name !== lastUnit.name) {
-                            otherFiles.push({ unitName: rootDir + unit.name, content: unit.content });
+                            otherFiles.push({ unitName: this.makeUnitName(unit.name, rootDir), content: unit.content });
                         }
                     });
-                } else {
+                }
+                else {
                     toBeCompiled = units.map(unit => {
-                        return { unitName: rootDir + unit.name, content: unit.content };
+                        return { unitName: this.makeUnitName(unit.name, rootDir), content: unit.content };
                     });
                 }
 
-                options = harnessCompiler.compileFiles(toBeCompiled, otherFiles, function (compileResult, _program) {
-                    result = compileResult;
-                    // The program will be used by typeWriter
-                    program = _program;
-                }, function (settings) {
-                        harnessCompiler.setCompilerSettings(tcSettings);
-                    });
-            });
+                const output = Harness.Compiler.compileFiles(
+                    toBeCompiled, otherFiles, harnessSettings, /* options */ undefined, /* currentDirectory */ undefined);
 
-            beforeEach(() => {
-                /* The compiler doesn't handle certain flags flipping during a single compilation setting. Tests on these flags will need
-                   a fresh compiler instance for themselves and then create a fresh one for the next test. Would be nice to get dev fixes
-                   eventually to remove this limitation. */
-                for (let i = 0; i < tcSettings.length; ++i) {
-                    // noImplicitAny is passed to getCompiler, but target is just passed in the settings blob to setCompilerSettings
-                    if (!createNewInstance && (tcSettings[i].flag == "noimplicitany" || tcSettings[i].flag === "target")) {
-                        harnessCompiler = Harness.Compiler.getCompiler();
-                        harnessCompiler.setCompilerSettings(tcSettings);
-                        createNewInstance = true;
-                    }
-                }
-            });
-
-            afterEach(() => {
-                if (createNewInstance) {
-                    harnessCompiler = Harness.Compiler.getCompiler();
-                    createNewInstance = false;
-                }
+                options = output.options;
+                result = output.result;
             });
 
             after(() => {
                 // Mocha holds onto the closure environment of the describe callback even after the test is done.
                 // Therefore we have to clean out large objects after the test is done.
                 justName = undefined;
-                content = undefined;
-                testCaseContent = undefined;
-                units = undefined;
-                tcSettings = undefined;
                 lastUnit = undefined;
-                rootDir = undefined;
+                hasNonDtsFiles = undefined;
                 result = undefined;
-                program = undefined;
                 options = undefined;
                 toBeCompiled = undefined;
                 otherFiles = undefined;
-                harnessCompiler = undefined;
             });
 
             function getByteOrderMarkText(file: Harness.Compiler.GeneratedFile): string {
                 return file.writeByteOrderMark ? "\u00EF\u00BB\u00BF" : "";
             }
 
-            function getErrorBaseline(toBeCompiled: { unitName: string; content: string }[], otherFiles: { unitName: string; content: string }[], result: Harness.Compiler.CompilerResult) {
+            function getErrorBaseline(toBeCompiled: Harness.Compiler.TestFile[], otherFiles: Harness.Compiler.TestFile[], result: Harness.Compiler.CompilerResult) {
                 return Harness.Compiler.getErrorBaseline(toBeCompiled.concat(otherFiles), result.errors);
             }
 
@@ -161,7 +130,7 @@ class CompilerBaselineRunner extends RunnerBase {
             it("Correct sourcemap content for " + fileName, () => {
                 if (options.sourceMap || options.inlineSourceMap) {
                     Harness.Baseline.runBaseline("Correct sourcemap content for " + fileName, justName.replace(/\.tsx?$/, ".sourcemap.txt"), () => {
-                        let record = result.getSourceMapRecord();
+                        const record = result.getSourceMapRecord();
                         if (options.noEmitOnError && result.errors.length !== 0 && record === undefined) {
                             // Because of the noEmitOnError option no files are created. We need to return null because baselining isn"t required.
                             return null;
@@ -172,7 +141,7 @@ class CompilerBaselineRunner extends RunnerBase {
             });
 
             it("Correct JS output for " + fileName, () => {
-                if (!ts.fileExtensionIs(lastUnit.name, ".d.ts") && this.emit) {
+                if (hasNonDtsFiles && this.emit) {
                     if (result.files.length === 0 && result.errors.length === 0) {
                         throw new Error("Expected at least one js file to be emitted or at least one error to be created.");
                     }
@@ -180,7 +149,7 @@ class CompilerBaselineRunner extends RunnerBase {
                     // check js output
                     Harness.Baseline.runBaseline("Correct JS output for " + fileName, justName.replace(/\.tsx?/, ".js"), () => {
                         let tsCode = "";
-                        let tsSources = otherFiles.concat(toBeCompiled);
+                        const tsSources = otherFiles.concat(toBeCompiled);
                         if (tsSources.length > 1) {
                             tsCode += "//// [" + fileName + "] ////\r\n\r\n";
                         }
@@ -205,9 +174,9 @@ class CompilerBaselineRunner extends RunnerBase {
                             }
                         }
 
-                        let declFileCompilationResult = harnessCompiler.compileDeclarationFiles(toBeCompiled, otherFiles, result, function (settings) {
-                            harnessCompiler.setCompilerSettings(tcSettings);
-                        }, options);
+                        const declFileCompilationResult =
+                            Harness.Compiler.compileDeclarationFiles(
+                                toBeCompiled, otherFiles, result, harnessSettings, options, /*currentDirectory*/ undefined);
 
                         if (declFileCompilationResult && declFileCompilationResult.declResult.errors.length) {
                             jsCode += "\r\n\r\n//// [DtsFileErrors]\r\n";
@@ -217,7 +186,8 @@ class CompilerBaselineRunner extends RunnerBase {
 
                         if (jsCode.length > 0) {
                             return tsCode + "\r\n\r\n" + jsCode;
-                        } else {
+                        }
+                        else {
                             return null;
                         }
                     });
@@ -277,15 +247,16 @@ class CompilerBaselineRunner extends RunnerBase {
                     // These types are equivalent, but depend on what order the compiler observed
                     // certain parts of the program.
 
-                    let allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
+                    const program = result.program;
+                    const allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
 
-                    let fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
-                    let pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
+                    const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true);
+                    const pullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ false);
 
-                    let fullResults: ts.Map<TypeWriterResult[]> = {};
-                    let pullResults: ts.Map<TypeWriterResult[]> = {};
+                    const fullResults: ts.Map<TypeWriterResult[]> = {};
+                    const pullResults: ts.Map<TypeWriterResult[]> = {};
 
-                    for (let sourceFile of allFiles) {
+                    for (const sourceFile of allFiles) {
                         fullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
                         pullResults[sourceFile.unitName] = fullWalker.getTypeAndSymbols(sourceFile.unitName);
                     }
@@ -294,14 +265,14 @@ class CompilerBaselineRunner extends RunnerBase {
                     // The second gives symbols for all identifiers.
                     let e1: Error, e2: Error;
                     try {
-                        checkBaseLines(/*isSymbolBaseLine:*/ false);
+                        checkBaseLines(/*isSymbolBaseLine*/ false);
                     }
                     catch (e) {
                         e1 = e;
                     }
 
                     try {
-                        checkBaseLines(/*isSymbolBaseLine:*/ true);
+                        checkBaseLines(/*isSymbolBaseLine*/ true);
                     }
                     catch (e) {
                         e2 = e;
@@ -314,11 +285,11 @@ class CompilerBaselineRunner extends RunnerBase {
                     return;
 
                     function checkBaseLines(isSymbolBaseLine: boolean) {
-                        let fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
-                        let pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
+                        const fullBaseLine = generateBaseLine(fullResults, isSymbolBaseLine);
+                        const pullBaseLine = generateBaseLine(pullResults, isSymbolBaseLine);
 
-                        let fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
-                        let pullExtension = isSymbolBaseLine ? ".symbols.pull" : ".types.pull";
+                        const fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
+                        const pullExtension = isSymbolBaseLine ? ".symbols.pull" : ".types.pull";
 
                         if (fullBaseLine !== pullBaseLine) {
                             Harness.Baseline.runBaseline("Correct full information for " + fileName, justName.replace(/\.tsx?/, fullExtension), () => fullBaseLine);
@@ -330,24 +301,24 @@ class CompilerBaselineRunner extends RunnerBase {
                     }
 
                     function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {
-                        let typeLines: string[] = [];
-                        let typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
+                        const typeLines: string[] = [];
+                        const typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
 
                         allFiles.forEach(file => {
-                            let codeLines = file.content.split("\n");
+                            const codeLines = file.content.split("\n");
                             typeWriterResults[file.unitName].forEach(result => {
                                 if (isSymbolBaseline && !result.symbol) {
                                     return;
                                 }
 
-                                let typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type;
-                                let formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString;
+                                const typeOrSymbolString = isSymbolBaseline ? result.symbol : result.type;
+                                const formattedLine = result.sourceText.replace(/\r?\n/g, "") + " : " + typeOrSymbolString;
                                 if (!typeMap[file.unitName]) {
                                     typeMap[file.unitName] = {};
                                 }
 
                                 let typeInfo = [formattedLine];
-                                let existingTypeInfo = typeMap[file.unitName][result.line];
+                                const existingTypeInfo = typeMap[file.unitName][result.line];
                                 if (existingTypeInfo) {
                                     typeInfo = existingTypeInfo.concat(typeInfo);
                                 }
@@ -356,10 +327,10 @@ class CompilerBaselineRunner extends RunnerBase {
 
                             typeLines.push("=== " + file.unitName + " ===\r\n");
                             for (let i = 0; i < codeLines.length; i++) {
-                                let currentCodeLine = codeLines[i];
+                                const currentCodeLine = codeLines[i];
                                 typeLines.push(currentCodeLine + "\r\n");
                                 if (typeMap[file.unitName]) {
-                                    let typeInfo = typeMap[file.unitName][i];
+                                    const typeInfo = typeMap[file.unitName][i];
                                     if (typeInfo) {
                                         typeInfo.forEach(ty => {
                                             typeLines.push(">" + ty + "\r\n");
@@ -387,13 +358,12 @@ class CompilerBaselineRunner extends RunnerBase {
     public initializeTests() {
         describe(this.testSuiteName + " tests", () => {
             describe("Setup compiler for compiler baselines", () => {
-                let harnessCompiler = Harness.Compiler.getCompiler();
                 this.parseOptions();
             });
 
             // this will set up a series of describe/it blocks to run between the setup and cleanup phases
             if (this.tests.length === 0) {
-                let testFiles = this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true });
+                const testFiles = this.enumerateFiles(this.basePath, /\.tsx?$/, { recursive: true });
                 testFiles.forEach(fn => {
                     fn = fn.replace(/\\/g, "/");
                     this.checkTestCodeOutput(fn);
@@ -402,10 +372,6 @@ class CompilerBaselineRunner extends RunnerBase {
             else {
                 this.tests.forEach(test => this.checkTestCodeOutput(test));
             }
-
-            describe("Cleanup after compiler baselines", () => {
-                let harnessCompiler = Harness.Compiler.getCompiler();
-            });
         });
     }
 
@@ -416,7 +382,7 @@ class CompilerBaselineRunner extends RunnerBase {
             this.decl = false;
             this.output = false;
 
-            let opts = this.options.split(",");
+            const opts = this.options.split(",");
             for (let i = 0; i < opts.length; i++) {
                 switch (opts[i]) {
                     case "error":

src/harness/fourslashRunner.ts

@@ -1,6 +1,7 @@
 ///<reference path="fourslash.ts" />
 ///<reference path="harness.ts"/>
 ///<reference path="runnerbase.ts" />
+/* tslint:disable:no-null */
 
 const enum FourSlashTestType {
     Native,
@@ -25,8 +26,8 @@ class FourSlashRunner extends RunnerBase {
                 this.testSuiteName = "fourslash-shims";
                 break;
             case FourSlashTestType.ShimsWithPreprocess:
-                this.basePath = 'tests/cases/fourslash/shims-pp';
-                this.testSuiteName = 'fourslash-shims-pp';
+                this.basePath = "tests/cases/fourslash/shims-pp";
+                this.testSuiteName = "fourslash-shims-pp";
                 break;
             case FourSlashTestType.Server:
                 this.basePath = "tests/cases/fourslash/server";
@@ -44,10 +45,10 @@ class FourSlashRunner extends RunnerBase {
             this.tests.forEach((fn: string) => {
                  describe(fn, () => {
                        fn = ts.normalizeSlashes(fn);
-                        let justName = fn.replace(/^.*[\\\/]/, "");
+                        const justName = fn.replace(/^.*[\\\/]/, "");
 
                         // Convert to relative path
-                        let testIndex = fn.indexOf("tests/");
+                        const testIndex = fn.indexOf("tests/");
                         if (testIndex >= 0) fn = fn.substr(testIndex);
 
                         if (justName && !justName.match(/fourslash\.ts$/i) && !justName.match(/\.d\.ts$/i)) {
@@ -57,55 +58,6 @@ class FourSlashRunner extends RunnerBase {
                     }
                 });
             });
-
-            describe("Generate Tao XML", () => {
-                let invalidReasons: any = {};
-                FourSlash.xmlData.forEach(xml => {
-                    if (xml.invalidReason !== null) {
-                        invalidReasons[xml.invalidReason] = (invalidReasons[xml.invalidReason] || 0) + 1;
-                    }
-                });
-                let invalidReport: { reason: string; count: number }[] = [];
-                for (let reason in invalidReasons) {
-                    if (invalidReasons.hasOwnProperty(reason)) {
-                        invalidReport.push({ reason: reason, count: invalidReasons[reason] });
-                    }
-                }
-                invalidReport.sort((lhs, rhs) => lhs.count > rhs.count ? -1 : lhs.count === rhs.count ? 0 : 1);
-
-                let lines: string[] = [];
-                lines.push("<!-- Blocked Test Report");
-                invalidReport.forEach((reasonAndCount) => {
-                    lines.push(reasonAndCount.count + " tests blocked by " + reasonAndCount.reason);
-                });
-                lines.push("-->");
-                lines.push("<TaoTest xmlns=\"http://microsoft.com/schemas/VSLanguages/TAO\">");
-                lines.push("    <InitTest>");
-                lines.push("        <StartTarget />");
-                lines.push("    </InitTest>");
-                lines.push("    <ScenarioList>");
-                FourSlash.xmlData.forEach(xml => {
-                    if (xml.invalidReason !== null) {
-                        lines.push("<!-- Skipped " + xml.originalName + ", reason: " + xml.invalidReason + " -->");
-                    } else {
-                        lines.push("        <Scenario Name=\"" + xml.originalName + "\">");
-                        xml.actions.forEach(action => {
-                            lines.push("            " + action);
-                        });
-                        lines.push("        </Scenario>");
-                    }
-                });
-                lines.push("    </ScenarioList>");
-                lines.push("    <CleanupScenario>");
-                lines.push("        <CloseAllDocuments />");
-                lines.push("        <CleanupCreatedFiles />");
-                lines.push("    </CleanupScenario>");
-                lines.push("    <CleanupTest>");
-                lines.push("        <CloseTarget />");
-                lines.push("    </CleanupTest>");
-                lines.push("</TaoTest>");
-                Harness.IO.writeFile("built/local/fourslash.xml", lines.join("\r\n"));
-            });
         });
     }
 }

src/harness/harnessLanguageService.ts

@@ -3,11 +3,11 @@
 /// <reference path="..\server\client.ts" />
 /// <reference path="harness.ts" />
 
-module Harness.LanguageService {
+namespace Harness.LanguageService {
     export class ScriptInfo {
         public version: number = 1;
         public editRanges: { length: number; textChangeRange: ts.TextChangeRange; }[] = [];
-        public lineMap: number[] = null;
+        private lineMap: number[] = undefined;
 
         constructor(public fileName: string, public content: string) {
             this.setContent(content);
@@ -15,7 +15,11 @@ module Harness.LanguageService {
 
         private setContent(content: string): void {
             this.content = content;
-            this.lineMap = ts.computeLineStarts(content);
+            this.lineMap = undefined;
+        }
+
+        public getLineMap(): number[] {
+            return this.lineMap || (this.lineMap = ts.computeLineStarts(this.content));
         }
 
         public updateContent(content: string): void {
@@ -26,9 +30,9 @@ module Harness.LanguageService {
 
         public editContent(start: number, end: number, newText: string): void {
             // Apply edits
-            let prefix = this.content.substring(0, start);
-            let middle = newText;
-            let suffix = this.content.substring(end);
+            const prefix = this.content.substring(0, start);
+            const middle = newText;
+            const suffix = this.content.substring(end);
             this.setContent(prefix + middle + suffix);
 
             // Store edit range + new length of script
@@ -48,10 +52,10 @@ module Harness.LanguageService {
                 return ts.unchangedTextChangeRange;
             }
 
-            let initialEditRangeIndex = this.editRanges.length - (this.version - startVersion);
-            let lastEditRangeIndex = this.editRanges.length - (this.version - endVersion);
+            const initialEditRangeIndex = this.editRanges.length - (this.version - startVersion);
+            const lastEditRangeIndex = this.editRanges.length - (this.version - endVersion);
 
-            let entries = this.editRanges.slice(initialEditRangeIndex, lastEditRangeIndex);
+            const entries = this.editRanges.slice(initialEditRangeIndex, lastEditRangeIndex);
             return ts.collapseTextChangeRangesAcrossMultipleVersions(entries.map(e => e.textChangeRange));
         }
     }
@@ -74,7 +78,7 @@ module Harness.LanguageService {
         }
 
         public getChangeRange(oldScript: ts.IScriptSnapshot): ts.TextChangeRange {
-            let oldShim = <ScriptSnapshot>oldScript;
+            const oldShim = <ScriptSnapshot>oldScript;
             return this.scriptInfo.getTextChangeRangeBetweenVersions(oldShim.version, this.version);
         }
     }
@@ -92,11 +96,11 @@ module Harness.LanguageService {
         }
 
         public getChangeRange(oldScript: ts.ScriptSnapshotShim): string {
-            let oldShim = <ScriptSnapshotProxy>oldScript;
+            const oldShim = <ScriptSnapshotProxy>oldScript;
 
-            let range = this.scriptSnapshot.getChangeRange(oldShim.scriptSnapshot);
-            if (range === null) {
-                return null;
+            const range = this.scriptSnapshot.getChangeRange(oldShim.scriptSnapshot);
+            if (range === undefined) {
+                return undefined;
             }
 
             return JSON.stringify({ span: { start: range.span.start, length: range.span.length }, newLength: range.newLength });
@@ -118,11 +122,11 @@ module Harness.LanguageService {
         getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo;
     }
 
-    export class LanguageServiceAdapterHost  {
+    export class LanguageServiceAdapterHost {
         protected fileNameToScript: ts.Map<ScriptInfo> = {};
-        
+
         constructor(protected cancellationToken = DefaultHostCancellationToken.Instance,
-                    protected settings = ts.getDefaultCompilerOptions()) { 
+                    protected settings = ts.getDefaultCompilerOptions()) {
         }
 
         public getNewLine(): string {
@@ -130,7 +134,7 @@ module Harness.LanguageService {
         }
 
         public getFilenames(): string[] {
-            let fileNames: string[] = [];
+            const fileNames: string[] = [];
             ts.forEachKey(this.fileNameToScript, (fileName) => { fileNames.push(fileName); });
             return fileNames;
         }
@@ -144,8 +148,8 @@ module Harness.LanguageService {
         }
 
         public editScript(fileName: string, start: number, end: number, newText: string) {
-            let script = this.getScriptInfo(fileName);
-            if (script !== null) {
+            const script = this.getScriptInfo(fileName);
+            if (script !== undefined) {
                 script.editContent(start, end, newText);
                 return;
             }
@@ -153,7 +157,7 @@ module Harness.LanguageService {
             throw new Error("No script with name '" + fileName + "'");
         }
 
-        public openFile(fileName: string): void {
+        public openFile(fileName: string, content?: string): void {
         }
 
         /**
@@ -161,26 +165,26 @@ module Harness.LanguageService {
           * @param col 0 based index
           */
         public positionToLineAndCharacter(fileName: string, position: number): ts.LineAndCharacter {
-            let script: ScriptInfo = this.fileNameToScript[fileName];
+            const script: ScriptInfo = this.fileNameToScript[fileName];
             assert.isNotNull(script);
 
-            return ts.computeLineAndCharacterOfPosition(script.lineMap, position);
+            return ts.computeLineAndCharacterOfPosition(script.getLineMap(), position);
         }
     }
 
     /// Native adapter
-    class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost { 
+    class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost {
         getCompilationSettings() { return this.settings; }
         getCancellationToken() { return this.cancellationToken; }
         getCurrentDirectory(): string { return ""; }
         getDefaultLibFileName(): string { return ""; }
         getScriptFileNames(): string[] { return this.getFilenames(); }
         getScriptSnapshot(fileName: string): ts.IScriptSnapshot {
-            let script = this.getScriptInfo(fileName);
+            const script = this.getScriptInfo(fileName);
             return script ? new ScriptSnapshot(script) : undefined;
         }
         getScriptVersion(fileName: string): string {
-            let script = this.getScriptInfo(fileName);
+            const script = this.getScriptInfo(fileName);
             return script ? script.version.toString() : undefined;
         }
 
@@ -191,46 +195,46 @@ module Harness.LanguageService {
 
     export class NativeLanugageServiceAdapter implements LanguageServiceAdapter {
         private host: NativeLanguageServiceHost;
-        constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) { 
+        constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
             this.host = new NativeLanguageServiceHost(cancellationToken, options);
         }
         getHost() { return this.host; }
         getLanguageService(): ts.LanguageService { return ts.createLanguageService(this.host); }
         getClassifier(): ts.Classifier { return ts.createClassifier(); }
-        getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo { return ts.preProcessFile(fileContents); }
+        getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo { return ts.preProcessFile(fileContents, /* readImportFiles */ true, ts.hasJavaScriptFileExtension(fileName)); }
     }
 
     /// Shim adapter
     class ShimLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceShimHost, ts.CoreServicesShimHost {
         private nativeHost: NativeLanguageServiceHost;
 
-        public getModuleResolutionsForFile: (fileName: string)=> string;
+        public getModuleResolutionsForFile: (fileName: string) => string;
 
         constructor(preprocessToResolve: boolean, cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
             super(cancellationToken, options);
             this.nativeHost = new NativeLanguageServiceHost(cancellationToken, options);
 
             if (preprocessToResolve) {
-                let compilerOptions = this.nativeHost.getCompilationSettings()
-                let moduleResolutionHost: ts.ModuleResolutionHost = {
+                const compilerOptions = this.nativeHost.getCompilationSettings();
+                const moduleResolutionHost: ts.ModuleResolutionHost = {
                     fileExists: fileName => this.getScriptInfo(fileName) !== undefined,
                     readFile: fileName => {
-                        let scriptInfo = this.getScriptInfo(fileName);
+                        const scriptInfo = this.getScriptInfo(fileName);
                         return scriptInfo && scriptInfo.content;
                     }
                 };
                 this.getModuleResolutionsForFile = (fileName) => {
-                    let scriptInfo = this.getScriptInfo(fileName);
-                    let preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
-                    let imports: ts.Map<string> = {};
-                    for (let module of preprocessInfo.importedFiles) {
-                        let resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
-                        if (resolutionInfo.resolvedFileName) {
-                            imports[module.fileName] = resolutionInfo.resolvedFileName;
+                    const scriptInfo = this.getScriptInfo(fileName);
+                    const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
+                    const imports: ts.Map<string> = {};
+                    for (const module of preprocessInfo.importedFiles) {
+                        const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
+                        if (resolutionInfo.resolvedModule) {
+                            imports[module.fileName] = resolutionInfo.resolvedModule.resolvedFileName;
                         }
                     }
                     return JSON.stringify(imports);
-                }
+                };
             }
         }
 
@@ -246,8 +250,8 @@ module Harness.LanguageService {
         getDefaultLibFileName(): string { return this.nativeHost.getDefaultLibFileName(); }
         getScriptFileNames(): string { return JSON.stringify(this.nativeHost.getScriptFileNames()); }
         getScriptSnapshot(fileName: string): ts.ScriptSnapshotShim {
-            let nativeScriptSnapshot = this.nativeHost.getScriptSnapshot(fileName);
-            return nativeScriptSnapshot && new ScriptSnapshotProxy(nativeScriptSnapshot); 
+            const nativeScriptSnapshot = this.nativeHost.getScriptSnapshot(fileName);
+            return nativeScriptSnapshot && new ScriptSnapshotProxy(nativeScriptSnapshot);
         }
         getScriptVersion(fileName: string): string { return this.nativeHost.getScriptVersion(fileName); }
         getLocalizedDiagnosticMessages(): string { return JSON.stringify({}); }
@@ -255,30 +259,30 @@ module Harness.LanguageService {
         readDirectory(rootDir: string, extension: string): string {
             throw new Error("NYI");
         }
-        fileExists(fileName: string) { return this.getScriptInfo(fileName) !== undefined; }        
-        readFile(fileName: string) { 
-            let snapshot = this.nativeHost.getScriptSnapshot(fileName);
+        fileExists(fileName: string) { return this.getScriptInfo(fileName) !== undefined; }
+        readFile(fileName: string) {
+            const snapshot = this.nativeHost.getScriptSnapshot(fileName);
             return snapshot && snapshot.getText(0, snapshot.getLength());
-        }        
+        }
         log(s: string): void { this.nativeHost.log(s); }
         trace(s: string): void { this.nativeHost.trace(s); }
         error(s: string): void { this.nativeHost.error(s); }
     }
 
-    class ClassifierShimProxy implements ts.Classifier { 
+    class ClassifierShimProxy implements ts.Classifier {
         constructor(private shim: ts.ClassifierShim) {
         }
         getEncodedLexicalClassifications(text: string, lexState: ts.EndOfLineState, classifyKeywordsInGenerics?: boolean): ts.Classifications {
             throw new Error("NYI");
         }
         getClassificationsForLine(text: string, lexState: ts.EndOfLineState, classifyKeywordsInGenerics?: boolean): ts.ClassificationResult {
-            let result = this.shim.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics).split("\n");
-            let entries: ts.ClassificationInfo[] = [];
+            const result = this.shim.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics).split("\n");
+            const entries: ts.ClassificationInfo[] = [];
             let i = 0;
             let position = 0;
 
             for (; i < result.length - 1; i += 2) {
-                let t = entries[i / 2] = {
+                const t = entries[i / 2] = {
                     length: parseInt(result[i]),
                     classification: parseInt(result[i + 1])
                 };
@@ -286,7 +290,7 @@ module Harness.LanguageService {
                 assert.isTrue(t.length > 0, "Result length should be greater than 0, got :" + t.length);
                 position += t.length;
             }
-            let finalLexState = parseInt(result[result.length - 1]);
+            const finalLexState = parseInt(result[result.length - 1]);
 
             assert.equal(position, text.length, "Expected cumulative length of all entries to match the length of the source. expected: " + text.length + ", but got: " + position);
 
@@ -298,11 +302,11 @@ module Harness.LanguageService {
     }
 
     function unwrapJSONCallResult(result: string): any {
-        let parsedResult = JSON.parse(result);
+        const parsedResult = JSON.parse(result);
         if (parsedResult.error) {
             throw new Error("Language Service Shim Error: " + JSON.stringify(parsedResult.error));
         }
-        else if (parsedResult.canceled) { 
+        else if (parsedResult.canceled) {
             throw new ts.OperationCanceledException();
         }
         return parsedResult.result;
@@ -312,7 +316,7 @@ module Harness.LanguageService {
         constructor(private shim: ts.LanguageServiceShim) {
         }
         private unwrappJSONCallResult(result: string): any {
-            let parsedResult = JSON.parse(result);
+            const parsedResult = JSON.parse(result);
             if (parsedResult.error) {
                 throw new Error("Language Service Shim Error: " + JSON.stringify(parsedResult.error));
             }
@@ -369,7 +373,7 @@ module Harness.LanguageService {
         getDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[] {
             return unwrapJSONCallResult(this.shim.getDefinitionAtPosition(fileName, position));
         }
-        getTypeDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[]{
+        getTypeDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[] {
             return unwrapJSONCallResult(this.shim.getTypeDefinitionAtPosition(fileName, position));
         }
         getReferencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] {
@@ -443,10 +447,10 @@ module Harness.LanguageService {
                 isLibFile: boolean;
             };
 
-            let coreServicesShim = this.factory.createCoreServicesShim(this.host);
+            const coreServicesShim = this.factory.createCoreServicesShim(this.host);
             shimResult = unwrapJSONCallResult(coreServicesShim.getPreProcessedFileInfo(fileName, ts.ScriptSnapshot.fromString(fileContents)));
 
-            let convertResult: ts.PreProcessedFileInfo = {
+            const convertResult: ts.PreProcessedFileInfo = {
                 referencedFiles: [],
                 importedFiles: [],
                 ambientExternalModules: [],
@@ -474,28 +478,28 @@ module Harness.LanguageService {
     }
 
     // Server adapter
-    class SessionClientHost extends NativeLanguageServiceHost implements ts.server.SessionClientHost { 
+    class SessionClientHost extends NativeLanguageServiceHost implements ts.server.SessionClientHost {
         private client: ts.server.SessionClient;
 
         constructor(cancellationToken: ts.HostCancellationToken, settings: ts.CompilerOptions) {
             super(cancellationToken, settings);
         }
 
-        onMessage(message: string): void { 
-        
+        onMessage(message: string): void {
+
         }
 
-        writeMessage(message: string): void { 
-        
+        writeMessage(message: string): void {
+
         }
 
         setClient(client: ts.server.SessionClient) {
             this.client = client;
         }
 
-        openFile(fileName: string): void {
-            super.openFile(fileName);
-            this.client.openFile(fileName);
+        openFile(fileName: string, content?: string): void {
+            super.openFile(fileName, content);
+            this.client.openFile(fileName, content);
         }
 
         editScript(fileName: string, start: number, end: number, newText: string) {
@@ -504,7 +508,7 @@ module Harness.LanguageService {
         }
     }
 
-    class SessionServerHost implements ts.server.ServerHost, ts.server.Logger { 
+    class SessionServerHost implements ts.server.ServerHost, ts.server.Logger {
         args: string[] = [];
         newLine: string;
         useCaseSensitiveFileNames: boolean = false;
@@ -513,24 +517,24 @@ module Harness.LanguageService {
             this.newLine = this.host.getNewLine();
         }
 
-        onMessage(message: string): void { 
-        
+        onMessage(message: string): void {
+
         }
 
         writeMessage(message: string): void {
         }
 
-        write(message: string): void { 
+        write(message: string): void {
             this.writeMessage(message);
         }
 
 
         readFile(fileName: string): string {
-            if (fileName.indexOf(Harness.Compiler.defaultLibFileName) >= 0) { 
+            if (fileName.indexOf(Harness.Compiler.defaultLibFileName) >= 0) {
                 fileName = Harness.Compiler.defaultLibFileName;
             }
-             
-            let snapshot = this.host.getScriptSnapshot(fileName);
+
+            const snapshot = this.host.getScriptSnapshot(fileName);
             return snapshot && snapshot.getText(0, snapshot.getLength());
         }
 
@@ -567,8 +571,12 @@ module Harness.LanguageService {
         readDirectory(path: string, extension?: string): string[] {
             throw new Error("Not implemented Yet.");
         }
-        
-        watchFile(fileName: string, callback: (fileName: string) => void): ts.FileWatcher { 
+
+        watchFile(fileName: string, callback: (fileName: string) => void): ts.FileWatcher {
+            return { close() { } };
+        }
+
+        watchDirectory(path: string, callback: (path: string) => void, recursive?: boolean): ts.FileWatcher {
             return { close() { } };
         }
 
@@ -582,7 +590,7 @@ module Harness.LanguageService {
         msg(message: string) {
             return this.host.log(message);
         }
-        
+
         loggingEnabled() {
             return true;
         }
@@ -602,19 +610,21 @@ module Harness.LanguageService {
         startGroup(): void {
         }
     }
-    
+
     export class ServerLanugageServiceAdapter implements LanguageServiceAdapter {
         private host: SessionClientHost;
         private client: ts.server.SessionClient;
         constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
             // This is the main host that tests use to direct tests
-            let clientHost = new SessionClientHost(cancellationToken, options);
-            let client = new ts.server.SessionClient(clientHost);
+            const clientHost = new SessionClientHost(cancellationToken, options);
+            const client = new ts.server.SessionClient(clientHost);
 
             // This host is just a proxy for the clientHost, it uses the client
             // host to answer server queries about files on disk
-            let serverHost = new SessionServerHost(clientHost);
-            let server = new ts.server.Session(serverHost, Buffer.byteLength, process.hrtime, serverHost);
+            const serverHost = new SessionServerHost(clientHost);
+            const server = new ts.server.Session(serverHost,
+                Buffer ? Buffer.byteLength : (string: string, encoding?: string) => string.length,
+                process.hrtime, serverHost);
 
             // Fake the connection between the client and the server
             serverHost.writeMessage = client.onMessage.bind(client);

src/harness/instrumenter.ts

@@ -3,11 +3,15 @@ var fs: any = require('fs');
 var path: any = require('path');
 
 function instrumentForRecording(fn: string, tscPath: string) {
-    instrument(tscPath, 'ts.sys = Playback.wrapSystem(ts.sys); ts.sys.startRecord("' + fn + '");', 'ts.sys.endRecord();');
+    instrument(tscPath, `
+ts.sys = Playback.wrapSystem(ts.sys);
+ts.sys.startRecord("${ fn }");`, `ts.sys.endRecord();`);
 }
 
 function instrumentForReplay(logFilename: string, tscPath: string) {
-    instrument(tscPath, 'ts.sys = Playback.wrapSystem(ts.sys); ts.sys.startReplay("' + logFilename + '");');
+    instrument(tscPath, `
+ts.sys = Playback.wrapSystem(ts.sys);
+ts.sys.startReplay("${ logFilename }");`);
 }
 
 function instrument(tscPath: string, prepareCode: string, cleanupCode: string = '') {

src/harness/loggedIO.ts

@@ -1,6 +1,7 @@
 /// <reference path="..\..\src\compiler\sys.ts" />
 /// <reference path="..\..\src\harness\harness.ts" />
 /// <reference path="..\..\src\harness\runnerbase.ts" />
+/* tslint:disable:no-null */
 
 interface FileInformation {
     contents: string;
@@ -59,6 +60,12 @@ interface IOLog {
         path: string;
         result?: string;
     }[];
+    directoriesRead: {
+        path: string,
+        extension: string,
+        exclude: string[],
+        result: string[]
+    }[];
 }
 
 interface PlaybackControl {
@@ -70,7 +77,7 @@ interface PlaybackControl {
     endRecord(): void;
 }
 
-module Playback {
+namespace Playback {
     let recordLog: IOLog = undefined;
     let replayLog: IOLog = undefined;
     let recordLogFileNameBase = "";
@@ -82,25 +89,28 @@ module Playback {
 
     function memoize<T>(func: (s: string) => T): Memoized<T> {
         let lookup: { [s: string]: T } = {};
-        let run: Memoized<T> = <Memoized<T>>((s: string) => {
+        const run: Memoized<T> = <Memoized<T>>((s: string) => {
             if (lookup.hasOwnProperty(s)) return lookup[s];
             return lookup[s] = func(s);
         });
         run.reset = () => {
             lookup = null;
         };
-    
+
         return run;
     }
 
     export interface PlaybackIO extends Harness.IO, PlaybackControl { }
 
+    export interface PlaybackSystem extends ts.System, PlaybackControl { }
+
     function createEmptyLog(): IOLog {
         return {
             timestamp: (new Date()).toString(),
             arguments: [],
             currentDirectory: "",
             filesRead: [],
+            directoriesRead: [],
             filesWritten: [],
             filesDeleted: [],
             filesAppended: [],
@@ -114,8 +124,10 @@ module Playback {
         };
     }
 
-    function initWrapper<T>(wrapper: PlaybackControl, underlying: T) {
-        Object.keys(underlying).forEach(prop => {
+    function initWrapper(wrapper: PlaybackSystem, underlying: ts.System): void;
+    function initWrapper(wrapper: PlaybackIO, underlying: Harness.IO): void;
+    function initWrapper(wrapper: PlaybackSystem | PlaybackIO, underlying: ts.System | Harness.IO): void {
+        ts.forEach(Object.keys(underlying), prop => {
             (<any>wrapper)[prop] = (<any>underlying)[prop];
         });
 
@@ -135,6 +147,93 @@ module Playback {
         wrapper.startRecord = (fileNameBase) => {
             recordLogFileNameBase = fileNameBase;
             recordLog = createEmptyLog();
+
+            if (typeof underlying.args !== "function") {
+                recordLog.arguments = <string[]>underlying.args;
+            }
+        };
+
+        wrapper.startReplayFromFile = logFn => {
+            wrapper.startReplayFromString(underlying.readFile(logFn));
+        };
+        wrapper.endRecord = () => {
+            if (recordLog !== undefined) {
+                let i = 0;
+                const fn = () => recordLogFileNameBase + i + ".json";
+                while (underlying.fileExists(fn())) i++;
+                underlying.writeFile(fn(), JSON.stringify(recordLog));
+                recordLog = undefined;
+            }
+        };
+
+        wrapper.fileExists = recordReplay(wrapper.fileExists, underlying)(
+            path => callAndRecord(underlying.fileExists(path), recordLog.fileExists, { path }),
+            memoize(path => {
+                // If we read from the file, it must exist
+                if (findResultByPath(wrapper, replayLog.filesRead, path, null) !== null) {
+                    return true;
+                }
+                else {
+                    return findResultByFields(replayLog.fileExists, { path }, /*defaultValue*/ false);
+                }
+            })
+        );
+
+        wrapper.getExecutingFilePath = () => {
+            if (replayLog !== undefined) {
+                return replayLog.executingPath;
+            }
+            else if (recordLog !== undefined) {
+                return recordLog.executingPath = underlying.getExecutingFilePath();
+            }
+            else {
+                return underlying.getExecutingFilePath();
+            }
+        };
+
+        wrapper.getCurrentDirectory = () => {
+            if (replayLog !== undefined) {
+                return replayLog.currentDirectory || "";
+            }
+            else if (recordLog !== undefined) {
+                return recordLog.currentDirectory = underlying.getCurrentDirectory();
+            }
+            else {
+                return underlying.getCurrentDirectory();
+            }
+        };
+
+        wrapper.resolvePath = recordReplay(wrapper.resolvePath, underlying)(
+            path => callAndRecord(underlying.resolvePath(path), recordLog.pathsResolved, { path }),
+            memoize(path => findResultByFields(replayLog.pathsResolved, { path }, !ts.isRootedDiskPath(ts.normalizeSlashes(path)) && replayLog.currentDirectory ? replayLog.currentDirectory + "/" + path : ts.normalizeSlashes(path))));
+
+        wrapper.readFile = recordReplay(wrapper.readFile, underlying)(
+            path => {
+                const result = underlying.readFile(path);
+                const logEntry = { path, codepage: 0, result: { contents: result, codepage: 0 } };
+                recordLog.filesRead.push(logEntry);
+                return result;
+            },
+            memoize(path => findResultByPath(wrapper, replayLog.filesRead, path).contents));
+
+        wrapper.readDirectory = recordReplay(wrapper.readDirectory, underlying)(
+            (path, extension, exclude) => {
+                const result = (<ts.System>underlying).readDirectory(path, extension, exclude);
+                const logEntry = { path, extension, exclude, result };
+                recordLog.directoriesRead.push(logEntry);
+                return result;
+            },
+            (path, extension, exclude) => findResultByPath(wrapper, replayLog.directoriesRead.filter(d => d.extension === extension && ts.arrayIsEqualTo(d.exclude, exclude)), path));
+
+        wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
+            (path, contents) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path, contents, bom: false }),
+            (path, contents) => noOpReplay("writeFile"));
+
+        wrapper.exit = (exitCode) => {
+            if (recordLog !== undefined) {
+                wrapper.endRecord();
+            }
+            underlying.exit(exitCode);
         };
     }
 
@@ -143,9 +242,11 @@ module Playback {
             return <any>(function () {
                 if (replayLog !== undefined) {
                     return replay.apply(undefined, arguments);
-                } else if (recordLog !== undefined) {
+                }
+                else if (recordLog !== undefined) {
                     return record.apply(undefined, arguments);
-                } else {
+                }
+                else {
                     return original.apply(underlying, arguments);
                 }
             });
@@ -162,14 +263,15 @@ module Playback {
     }
 
     function findResultByFields<T>(logArray: { result?: T }[], expectedFields: {}, defaultValue?: T): T {
-        let predicate = (entry: { result?: T }) => {
+        const predicate = (entry: { result?: T }) => {
             return Object.getOwnPropertyNames(expectedFields).every((name) => (<any>entry)[name] === (<any>expectedFields)[name]);
         };
-        let results = logArray.filter(entry => predicate(entry));
+        const results = logArray.filter(entry => predicate(entry));
         if (results.length === 0) {
             if (defaultValue !== undefined) {
                 return defaultValue;
-            } else {
+            }
+            else {
                 throw new Error("No matching result in log array for: " + JSON.stringify(expectedFields));
             }
         }
@@ -177,7 +279,7 @@ module Playback {
     }
 
     function findResultByPath<T>(wrapper: { resolvePath(s: string): string }, logArray: { path: string; result?: T }[], expectedPath: string, defaultValue?: T): T {
-        let normalizedName = ts.normalizeSlashes(expectedPath).toLowerCase();
+        const normalizedName = ts.normalizePath(expectedPath).toLowerCase();
         // Try to find the result through normal fileName
         for (let i = 0; i < logArray.length; i++) {
             if (ts.normalizeSlashes(logArray[i].path).toLowerCase() === normalizedName) {
@@ -186,24 +288,26 @@ module Playback {
         }
         // Fallback, try to resolve the target paths as well
         if (replayLog.pathsResolved.length > 0) {
-            let normalizedResolvedName = wrapper.resolvePath(expectedPath).toLowerCase();
+            const normalizedResolvedName = wrapper.resolvePath(expectedPath).toLowerCase();
             for (let i = 0; i < logArray.length; i++) {
                 if (wrapper.resolvePath(logArray[i].path).toLowerCase() === normalizedResolvedName) {
                     return logArray[i].result;
                 }
             }
         }
+
         // If we got here, we didn't find a match
         if (defaultValue === undefined) {
             throw new Error("No matching result in log array for path: " + expectedPath);
-        } else {
+        }
+        else {
             return defaultValue;
         }
     }
 
-    let pathEquivCache: any = {};
+    const pathEquivCache: any = {};
     function pathsAreEquivalent(left: string, right: string, wrapper: { resolvePath(s: string): string }) {
-        let key = left + "-~~-" + right;
+        const key = left + "-~~-" + right;
         function areSame(a: string, b: string) {
             return ts.normalizeSlashes(a).toLowerCase() === ts.normalizeSlashes(b).toLowerCase();
         }
@@ -214,7 +318,8 @@ module Playback {
         }
         if (pathEquivCache.hasOwnProperty(key)) {
             return pathEquivCache[key];
-        } else {
+        }
+        else {
             return pathEquivCache[key] = check();
         }
     }
@@ -224,96 +329,21 @@ module Playback {
     }
 
     export function wrapIO(underlying: Harness.IO): PlaybackIO {
-        let wrapper: PlaybackIO = <any>{};
+        const wrapper: PlaybackIO = <any>{};
         initWrapper(wrapper, underlying);
 
-        wrapper.startReplayFromFile = logFn => {
-            wrapper.startReplayFromString(underlying.readFile(logFn));
-        };
-        wrapper.endRecord = () => {
-            if (recordLog !== undefined) {
-                let i = 0;
-                let fn = () => recordLogFileNameBase + i + ".json";
-                while (underlying.fileExists(fn())) i++;
-                underlying.writeFile(fn(), JSON.stringify(recordLog));
-                recordLog = undefined;
-            }
-        };
-        
-        wrapper.args = () => {
-            if (replayLog !== undefined) {
-                return replayLog.arguments;
-            } else if (recordLog !== undefined) {
-                recordLog.arguments = underlying.args();
-            }
-            return underlying.args();
-        }
-        
-        wrapper.newLine = () => underlying.newLine();
-        wrapper.useCaseSensitiveFileNames = () => underlying.useCaseSensitiveFileNames();
         wrapper.directoryName = (path): string => { throw new Error("NotSupported"); };
-        wrapper.createDirectory = path => { throw new Error("NotSupported"); };
+        wrapper.createDirectory = (path): void => { throw new Error("NotSupported"); };
         wrapper.directoryExists = (path): boolean => { throw new Error("NotSupported"); };
-        wrapper.deleteFile = path => { throw new Error("NotSupported"); };
+        wrapper.deleteFile = (path): void => { throw new Error("NotSupported"); };
         wrapper.listFiles = (path, filter, options): string[] => { throw new Error("NotSupported"); };
-        wrapper.log = text => underlying.log(text);
-
-        wrapper.fileExists = recordReplay(wrapper.fileExists, underlying)(
-            (path) => callAndRecord(underlying.fileExists(path), recordLog.fileExists, { path: path }),
-            memoize((path) => {
-                // If we read from the file, it must exist
-                if (findResultByPath(wrapper, replayLog.filesRead, path, null) !== null) {
-                    return true;
-                } else {
-                    return findResultByFields(replayLog.fileExists, { path: path }, false);
-                }
-            })
-        );
-
-        wrapper.getExecutingFilePath = () => {
-            if (replayLog !== undefined) {
-                return replayLog.executingPath;
-            } else if (recordLog !== undefined) {
-                return recordLog.executingPath = underlying.getExecutingFilePath();
-            } else {
-                return underlying.getExecutingFilePath();
-            }
-        };
-
-        wrapper.getCurrentDirectory = () => {
-            if (replayLog !== undefined) {
-                return replayLog.currentDirectory || "";
-            } else if (recordLog !== undefined) {
-                return recordLog.currentDirectory = underlying.getCurrentDirectory();
-            } else {
-                return underlying.getCurrentDirectory();
-            }
-        };
-
-        wrapper.resolvePath = recordReplay(wrapper.resolvePath, underlying)(
-            (path) => callAndRecord(underlying.resolvePath(path), recordLog.pathsResolved, { path: path }),
-            memoize((path) => findResultByFields(replayLog.pathsResolved, { path: path }, !ts.isRootedDiskPath(ts.normalizeSlashes(path)) && replayLog.currentDirectory ? replayLog.currentDirectory + "/" + path : ts.normalizeSlashes(path))));
-
-        wrapper.readFile = recordReplay(wrapper.readFile, underlying)(
-            (path) => {
-                let result = underlying.readFile(path);
-                let logEntry = { path: path, codepage: 0, result: { contents: result, codepage: 0 } };
-                recordLog.filesRead.push(logEntry);
-                return result;
-            },
-            memoize((path) => findResultByPath(wrapper, replayLog.filesRead, path).contents));
-
-        wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
-            (path, contents) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path: path, contents: contents, bom: false }),
-            (path, contents) => noOpReplay("writeFile"));
-
-        wrapper.exit = (exitCode) => {
-            if (recordLog !== undefined) {
-                wrapper.endRecord();
-            }
-            underlying.exit(exitCode);
-        };
 
         return wrapper;
     }
+
+    export function wrapSystem(underlying: ts.System): PlaybackSystem {
+        const wrapper: PlaybackSystem = <any>{};
+        initWrapper(wrapper, underlying);
+        return wrapper;
+    }
 }

src/harness/projectsRunner.ts

@@ -1,24 +1,17 @@
 ///<reference path="harness.ts" />
 ///<reference path="runnerbase.ts" />
+/* tslint:disable:no-null */
 
 // Test case is json of below type in tests/cases/project/
 interface ProjectRunnerTestCase {
     scenario: string;
     projectRoot: string; // project where it lives - this also is the current directory when compiling
     inputFiles: string[]; // list of input files to be given to program
-    out?: string; // --out
-    outDir?: string; // --outDir
-    sourceMap?: boolean; // --map
-    mapRoot?: string; // --mapRoot
     resolveMapRoot?: boolean; // should we resolve this map root and give compiler the absolute disk path as map root?
-    sourceRoot?: string; // --sourceRoot
     resolveSourceRoot?: boolean; // should we resolve this source root and give compiler the absolute disk path as map root?
-    declaration?: boolean; // --d
     baselineCheck?: boolean; // Verify the baselines of output files, if this is false, we will write to output to the disk but there is no verification of baselines
     runTest?: boolean; // Run the resulting test
     bug?: string; // If there is any bug associated with this test case
-    noResolve?: boolean;
-    rootDir?: string; // --rootDir
 }
 
 interface ProjectRunnerTestCaseResolutionInfo extends ProjectRunnerTestCase {
@@ -33,20 +26,20 @@ interface BatchCompileProjectTestCaseEmittedFile extends Harness.Compiler.Genera
 
 interface CompileProjectFilesResult {
     moduleKind: ts.ModuleKind;
-    program: ts.Program;
+    program?: ts.Program;
+    compilerOptions?: ts.CompilerOptions;
     errors: ts.Diagnostic[];
-    sourceMapData: ts.SourceMapData[];
+    sourceMapData?: ts.SourceMapData[];
 }
 
 interface BatchCompileProjectTestCaseResult extends CompileProjectFilesResult {
-    outputFiles: BatchCompileProjectTestCaseEmittedFile[];
-    nonSubfolderDiskFiles: number;
+    outputFiles?: BatchCompileProjectTestCaseEmittedFile[];
 }
 
 class ProjectRunner extends RunnerBase {
     public initializeTests() {
         if (this.tests.length === 0) {
-            let testFiles = this.enumerateFiles("tests/cases/project", /\.json$/, { recursive: true });
+            const testFiles = this.enumerateFiles("tests/cases/project", /\.json$/, { recursive: true });
             testFiles.forEach(fn => {
                 fn = fn.replace(/\\/g, "/");
                 this.runProjectTestCase(fn);
@@ -58,7 +51,7 @@ class ProjectRunner extends RunnerBase {
     }
 
     private runProjectTestCase(testCaseFileName: string) {
-        let testCase: ProjectRunnerTestCase;
+        let testCase: ProjectRunnerTestCase & ts.CompilerOptions;
 
         let testFileText: string = null;
         try {
@@ -69,7 +62,7 @@ class ProjectRunner extends RunnerBase {
         }
 
         try {
-            testCase = <ProjectRunnerTestCase>JSON.parse(testFileText);
+            testCase = <ProjectRunnerTestCase & ts.CompilerOptions>JSON.parse(testFileText);
         }
         catch (e) {
             assert(false, "Testcase: " + testCaseFileName + " does not contain valid json format: " + e.message);
@@ -100,7 +93,7 @@ class ProjectRunner extends RunnerBase {
         function cleanProjectUrl(url: string) {
             let diskProjectPath = ts.normalizeSlashes(Harness.IO.resolvePath(testCase.projectRoot));
             let projectRootUrl = "file:///" + diskProjectPath;
-            let normalizedProjectRoot = ts.normalizeSlashes(testCase.projectRoot);
+            const normalizedProjectRoot = ts.normalizeSlashes(testCase.projectRoot);
             diskProjectPath = diskProjectPath.substr(0, diskProjectPath.lastIndexOf(normalizedProjectRoot));
             projectRootUrl = projectRootUrl.substr(0, projectRootUrl.lastIndexOf(normalizedProjectRoot));
             if (url && url.length) {
@@ -126,15 +119,16 @@ class ProjectRunner extends RunnerBase {
         }
 
         function compileProjectFiles(moduleKind: ts.ModuleKind, getInputFiles: () => string[],
-            getSourceFileText: (fileName: string) => string,
-            writeFile: (fileName: string, data: string, writeByteOrderMark: boolean) => void): CompileProjectFilesResult {
+            getSourceFileTextImpl: (fileName: string) => string,
+            writeFile: (fileName: string, data: string, writeByteOrderMark: boolean) => void,
+            compilerOptions: ts.CompilerOptions): CompileProjectFilesResult {
 
-            let program = ts.createProgram(getInputFiles(), createCompilerOptions(), createCompilerHost());
+            const program = ts.createProgram(getInputFiles(), compilerOptions, createCompilerHost());
             let errors = ts.getPreEmitDiagnostics(program);
 
-            let emitResult = program.emit();
+            const emitResult = program.emit();
             errors = ts.concatenate(errors, emitResult.diagnostics);
-            let sourceMapData = emitResult.sourceMaps;
+            const sourceMapData = emitResult.sourceMaps;
 
             // Clean up source map data that will be used in baselining
             if (sourceMapData) {
@@ -154,19 +148,9 @@ class ProjectRunner extends RunnerBase {
                 sourceMapData
             };
 
-            function createCompilerOptions(): ts.CompilerOptions {
-                return {
-                    declaration: !!testCase.declaration,
-                    sourceMap: !!testCase.sourceMap,
-                    outFile: testCase.out,
-                    outDir: testCase.outDir,
-                    mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? Harness.IO.resolvePath(testCase.mapRoot) : testCase.mapRoot,
-                    sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? Harness.IO.resolvePath(testCase.sourceRoot) : testCase.sourceRoot,
-                    module: moduleKind,
-                    moduleResolution: ts.ModuleResolutionKind.Classic, // currently all tests use classic module resolution kind, this will change in the future 
-                    noResolve: testCase.noResolve,
-                    rootDir: testCase.rootDir
-                };
+            function getSourceFileText(fileName: string): string {
+                const text = getSourceFileTextImpl(fileName);
+                return text !== undefined ? text : getSourceFileTextImpl(ts.getNormalizedAbsolutePath(fileName, getCurrentDirectory()));
             }
 
             function getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile {
@@ -175,7 +159,7 @@ class ProjectRunner extends RunnerBase {
                     sourceFile = languageVersion === ts.ScriptTarget.ES6 ? Harness.Compiler.defaultES6LibSourceFile : Harness.Compiler.defaultLibSourceFile;
                 }
                 else {
-                    let text = getSourceFileText(fileName);
+                    const text = getSourceFileText(fileName);
                     if (text !== undefined) {
                         sourceFile = Harness.Compiler.createSourceFileAndAssertInvariants(fileName, text, languageVersion);
                     }
@@ -193,33 +177,115 @@ class ProjectRunner extends RunnerBase {
                     getCanonicalFileName: Harness.Compiler.getCanonicalFileName,
                     useCaseSensitiveFileNames: () => Harness.IO.useCaseSensitiveFileNames(),
                     getNewLine: () => Harness.IO.newLine(),
-                    fileExists: fileName => getSourceFile(fileName, ts.ScriptTarget.ES5) !== undefined,
+                    fileExists: fileName => fileName === Harness.Compiler.defaultLibFileName ||  getSourceFileText(fileName) !== undefined,
                     readFile: fileName => Harness.IO.readFile(fileName)
                 };
             }
         }
 
-        function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult{
+        function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult {
             let nonSubfolderDiskFiles = 0;
 
-            let outputFiles: BatchCompileProjectTestCaseEmittedFile[] = [];
+            const outputFiles: BatchCompileProjectTestCaseEmittedFile[] = [];
+            let inputFiles = testCase.inputFiles;
+            let compilerOptions = createCompilerOptions();
 
-            let projectCompilerResult = compileProjectFiles(moduleKind, () => testCase.inputFiles, getSourceFileText, writeFile);
+            let configFileName: string;
+            if (compilerOptions.project) {
+                // Parse project
+                configFileName = ts.normalizePath(ts.combinePaths(compilerOptions.project, "tsconfig.json"));
+                assert(!inputFiles || inputFiles.length === 0, "cannot specify input files and project option together");
+            }
+            else if (!inputFiles || inputFiles.length === 0) {
+                configFileName = ts.findConfigFile("", fileExists);
+            }
+
+            if (configFileName) {
+                const result = ts.readConfigFile(configFileName, getSourceFileText);
+                if (result.error) {
+                    return {
+                        moduleKind,
+                        errors: [result.error]
+                    };
+                }
+
+                const configObject = result.config;
+                const configParseResult = ts.parseJsonConfigFileContent(configObject, { readDirectory }, ts.getDirectoryPath(configFileName), compilerOptions);
+                if (configParseResult.errors.length > 0) {
+                    return {
+                        moduleKind,
+                        errors: configParseResult.errors
+                    };
+                }
+                inputFiles = configParseResult.fileNames;
+                compilerOptions = configParseResult.options;
+            }
+
+            const projectCompilerResult = compileProjectFiles(moduleKind, () => inputFiles, getSourceFileText, writeFile, compilerOptions);
             return {
                 moduleKind,
                 program: projectCompilerResult.program,
+                compilerOptions,
                 sourceMapData: projectCompilerResult.sourceMapData,
                 outputFiles,
                 errors: projectCompilerResult.errors,
-                nonSubfolderDiskFiles,
             };
 
+            function createCompilerOptions() {
+                // Set the special options that depend on other testcase options
+                const compilerOptions: ts.CompilerOptions = {
+                    mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? Harness.IO.resolvePath(testCase.mapRoot) : testCase.mapRoot,
+                    sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? Harness.IO.resolvePath(testCase.sourceRoot) : testCase.sourceRoot,
+                    module: moduleKind,
+                    moduleResolution: ts.ModuleResolutionKind.Classic, // currently all tests use classic module resolution kind, this will change in the future 
+                };
+                // Set the values specified using json
+                const optionNameMap: ts.Map<ts.CommandLineOption> = {};
+                ts.forEach(ts.optionDeclarations, option => {
+                    optionNameMap[option.name] = option;
+                });
+                for (const name in testCase) {
+                    if (name !== "mapRoot" && name !== "sourceRoot" && ts.hasProperty(optionNameMap, name)) {
+                        const option = optionNameMap[name];
+                        const optType = option.type;
+                        let value = <any>testCase[name];
+                        if (typeof optType !== "string") {
+                            const key = value.toLowerCase();
+                            if (ts.hasProperty(optType, key)) {
+                                value = optType[key];
+                            }
+                        }
+                        compilerOptions[option.name] = value;
+                    }
+                }
+
+                return compilerOptions;
+            }
+
+            function getFileNameInTheProjectTest(fileName: string): string {
+                return ts.isRootedDiskPath(fileName)
+                    ? fileName
+                    : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(fileName);
+            }
+
+            function readDirectory(rootDir: string, extension: string, exclude: string[]): string[] {
+                const harnessReadDirectoryResult = Harness.IO.readDirectory(getFileNameInTheProjectTest(rootDir), extension, exclude);
+                const result: string[] = [];
+                for (let i = 0; i < harnessReadDirectoryResult.length; i++) {
+                    result[i] = ts.getRelativePathToDirectoryOrUrl(testCase.projectRoot, harnessReadDirectoryResult[i],
+                        getCurrentDirectory(), Harness.Compiler.getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
+                }
+                return result;
+            }
+
+            function fileExists(fileName: string): boolean {
+                return Harness.IO.fileExists(getFileNameInTheProjectTest(fileName));
+            }
+
             function getSourceFileText(fileName: string): string {
                 let text: string = undefined;
                 try {
-                    text = Harness.IO.readFile(ts.isRootedDiskPath(fileName)
-                        ? fileName
-                        : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(fileName));
+                    text = Harness.IO.readFile(getFileNameInTheProjectTest(fileName));
                 }
                 catch (e) {
                     // text doesn't get defined.
@@ -228,12 +294,15 @@ class ProjectRunner extends RunnerBase {
             }
 
             function writeFile(fileName: string, data: string, writeByteOrderMark: boolean) {
-                let diskFileName = ts.isRootedDiskPath(fileName)
+                // convert file name to rooted name
+                // if filename is not rooted - concat it with project root and then expand project root relative to current directory
+                const diskFileName = ts.isRootedDiskPath(fileName)
                     ? fileName
-                    : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(fileName);
+                    : Harness.IO.resolvePath(ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(fileName));
 
-                let diskRelativeName = ts.getRelativePathToDirectoryOrUrl(testCase.projectRoot, diskFileName,
-                    getCurrentDirectory(), Harness.Compiler.getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
+                const currentDirectory = getCurrentDirectory();
+                // compute file name relative to current directory (expanded project root)
+                let diskRelativeName = ts.getRelativePathToDirectoryOrUrl(currentDirectory, diskFileName, currentDirectory, Harness.Compiler.getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
                 if (ts.isRootedDiskPath(diskRelativeName) || diskRelativeName.substr(0, 3) === "../") {
                     // If the generated output file resides in the parent folder or is rooted path,
                     // we need to instead create files that can live in the project reference folder
@@ -245,14 +314,14 @@ class ProjectRunner extends RunnerBase {
 
                 if (Harness.Compiler.isJS(fileName)) {
                     // Make sure if there is URl we have it cleaned up
-                    let indexOfSourceMapUrl = data.lastIndexOf("//# sourceMappingURL=");
+                    const indexOfSourceMapUrl = data.lastIndexOf("//# sourceMappingURL=");
                     if (indexOfSourceMapUrl !== -1) {
                         data = data.substring(0, indexOfSourceMapUrl + 21) + cleanProjectUrl(data.substring(indexOfSourceMapUrl + 21));
                     }
                 }
                 else if (Harness.Compiler.isJSMap(fileName)) {
                     // Make sure sources list is cleaned
-                    let sourceMapData = JSON.parse(data);
+                    const sourceMapData = JSON.parse(data);
                     for (let i = 0; i < sourceMapData.sources.length; i++) {
                         sourceMapData.sources[i] = cleanProjectUrl(sourceMapData.sources[i]);
                     }
@@ -260,7 +329,7 @@ class ProjectRunner extends RunnerBase {
                     data = JSON.stringify(sourceMapData);
                 }
 
-                let outputFilePath = getProjectOutputFolder(diskRelativeName, moduleKind);
+                const outputFilePath = getProjectOutputFolder(diskRelativeName, moduleKind);
                 // Actual writing of file as in tc.ts
                 function ensureDirectoryStructure(directoryname: string) {
                     if (directoryname) {
@@ -278,14 +347,17 @@ class ProjectRunner extends RunnerBase {
         }
 
         function compileCompileDTsFiles(compilerResult: BatchCompileProjectTestCaseResult) {
-            let allInputFiles: { emittedFileName: string; code: string; }[] = [];
-            let compilerOptions = compilerResult.program.getCompilerOptions();
+            const allInputFiles: { emittedFileName: string; code: string; }[] = [];
+            if (!compilerResult.program) {
+                return;
+            }
+            const compilerOptions = compilerResult.program.getCompilerOptions();
 
             ts.forEach(compilerResult.program.getSourceFiles(), sourceFile => {
-                if (Harness.Compiler.isDTS(sourceFile.fileName)) {
+                if (ts.isDeclarationFile(sourceFile)) {
                     allInputFiles.unshift({ emittedFileName: sourceFile.fileName, code: sourceFile.text });
                 }
-                else if (ts.shouldEmitToOwnFile(sourceFile, compilerResult.program.getCompilerOptions())) {
+                else if (!(compilerOptions.outFile || compilerOptions.out)) {
                     let emitOutputFilePathWithoutExtension: string = undefined;
                     if (compilerOptions.outDir) {
                         let sourceFilePath = ts.getNormalizedAbsolutePath(sourceFile.fileName, compilerResult.program.getCurrentDirectory());
@@ -296,19 +368,23 @@ class ProjectRunner extends RunnerBase {
                         emitOutputFilePathWithoutExtension = ts.removeFileExtension(sourceFile.fileName);
                     }
 
-                    let outputDtsFileName = emitOutputFilePathWithoutExtension + ".d.ts";
-                    allInputFiles.unshift(findOutpuDtsFile(outputDtsFileName));
+                    const outputDtsFileName = emitOutputFilePathWithoutExtension + ".d.ts";
+                    const file = findOutpuDtsFile(outputDtsFileName);
+                    if (file) {
+                        allInputFiles.unshift(file);
+                    }
                 }
                 else {
-                    let outputDtsFileName = ts.removeFileExtension(compilerOptions.outFile|| compilerOptions.out) + ".d.ts";
-                    let outputDtsFile = findOutpuDtsFile(outputDtsFileName);
+                    const outputDtsFileName = ts.removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts";
+                    const outputDtsFile = findOutpuDtsFile(outputDtsFileName);
                     if (!ts.contains(allInputFiles, outputDtsFile)) {
                         allInputFiles.unshift(outputDtsFile);
                     }
                 }
             });
 
-            return compileProjectFiles(compilerResult.moduleKind, getInputFiles, getSourceFileText, writeFile);
+            // Dont allow config files since we are compiling existing source options
+            return compileProjectFiles(compilerResult.moduleKind, getInputFiles, getSourceFileText, writeFile, compilerResult.compilerOptions);
 
             function findOutpuDtsFile(fileName: string) {
                 return ts.forEach(compilerResult.outputFiles, outputFile => outputFile.emittedFileName === fileName ? outputFile : undefined);
@@ -317,7 +393,16 @@ class ProjectRunner extends RunnerBase {
                 return ts.map(allInputFiles, outputFile => outputFile.emittedFileName);
             }
             function getSourceFileText(fileName: string): string {
-                return ts.forEach(allInputFiles, inputFile => inputFile.emittedFileName === fileName ? inputFile.code : undefined);
+                for (const inputFile of allInputFiles) {
+                    const isMatchingFile = ts.isRootedDiskPath(fileName)
+                        ? ts.getNormalizedAbsolutePath(inputFile.emittedFileName, getCurrentDirectory()) === fileName
+                        : inputFile.emittedFileName === fileName;
+
+                    if (isMatchingFile) {
+                        return inputFile.code;
+                    }
+                }
+                return undefined;
             }
 
             function writeFile(fileName: string, data: string, writeByteOrderMark: boolean) {
@@ -325,16 +410,21 @@ class ProjectRunner extends RunnerBase {
         }
 
         function getErrorsBaseline(compilerResult: CompileProjectFilesResult) {
-            let inputFiles = ts.map(ts.filter(compilerResult.program.getSourceFiles(),
+            const inputFiles = compilerResult.program ? ts.map(ts.filter(compilerResult.program.getSourceFiles(),
                 sourceFile => sourceFile.fileName !== "lib.d.ts"),
                 sourceFile => {
-                    return { unitName: sourceFile.fileName, content: sourceFile.text };
-                });
+                    return {
+                        unitName: ts.isRootedDiskPath(sourceFile.fileName) ?
+                            RunnerBase.removeFullPaths(sourceFile.fileName) :
+                            sourceFile.fileName,
+                        content: sourceFile.text
+                    };
+                }) : [];
 
             return Harness.Compiler.getErrorBaseline(inputFiles, compilerResult.errors);
         }
 
-        let name = "Compiling project for " + testCase.scenario + ": testcase " + testCaseFileName;
+        const name = "Compiling project for " + testCase.scenario + ": testcase " + testCaseFileName;
 
         describe("Projects tests", () => {
             describe(name, () => {
@@ -342,30 +432,17 @@ class ProjectRunner extends RunnerBase {
                     let compilerResult: BatchCompileProjectTestCaseResult;
 
                     function getCompilerResolutionInfo() {
-                        let resolutionInfo: ProjectRunnerTestCaseResolutionInfo = {
-                            scenario: testCase.scenario,
-                            projectRoot: testCase.projectRoot,
-                            inputFiles: testCase.inputFiles,
-                            out: testCase.out,
-                            outDir: testCase.outDir,
-                            sourceMap: testCase.sourceMap,
-                            mapRoot: testCase.mapRoot,
-                            resolveMapRoot: testCase.resolveMapRoot,
-                            sourceRoot: testCase.sourceRoot,
-                            resolveSourceRoot: testCase.resolveSourceRoot,
-                            declaration: testCase.declaration,
-                            baselineCheck: testCase.baselineCheck,
-                            runTest: testCase.runTest,
-                            bug: testCase.bug,
-                            rootDir: testCase.rootDir,
-                            resolvedInputFiles: ts.map(compilerResult.program.getSourceFiles(), inputFile => inputFile.fileName),
-                            emittedFiles: ts.map(compilerResult.outputFiles, outputFile => outputFile.emittedFileName)
-                        };
-
+                        const resolutionInfo: ProjectRunnerTestCaseResolutionInfo & ts.CompilerOptions = JSON.parse(JSON.stringify(testCase));
+                        resolutionInfo.resolvedInputFiles = ts.map(compilerResult.program.getSourceFiles(), inputFile => {
+                            return ts.convertToRelativePath(inputFile.fileName, getCurrentDirectory(), path => Harness.Compiler.getCanonicalFileName(path));
+                        });
+                        resolutionInfo.emittedFiles = ts.map(compilerResult.outputFiles, outputFile => {
+                            return ts.convertToRelativePath(outputFile.emittedFileName, getCurrentDirectory(), path => Harness.Compiler.getCanonicalFileName(path));
+                        });
                         return resolutionInfo;
                     }
 
-                    it(name + ": " + moduleNameToString(moduleKind) , () => {
+                    it(name + ": " + moduleNameToString(moduleKind), () => {
                         // Compile using node
                         compilerResult = batchCompilerProjectTestCase(moduleKind);
                     });
@@ -416,8 +493,8 @@ class ProjectRunner extends RunnerBase {
 
                     it("Errors in generated Dts files for (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                         if (!compilerResult.errors.length && testCase.declaration) {
-                            let dTsCompileResult = compileCompileDTsFiles(compilerResult);
-                            if (dTsCompileResult.errors.length) {
+                            const dTsCompileResult = compileCompileDTsFiles(compilerResult);
+                            if (dTsCompileResult && dTsCompileResult.errors.length) {
                                 Harness.Baseline.runBaseline("Errors in generated Dts files for (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + testCaseJustName + ".dts.errors.txt", () => {
                                     return getErrorsBaseline(dTsCompileResult);
                                 });

src/harness/runner.ts

@@ -20,8 +20,10 @@
 /// <reference path="rwcRunner.ts" />
 /// <reference path="harness.ts" />
 
+/* tslint:disable:no-null */
+
 let runners: RunnerBase[] = [];
-let iterations: number = 1;
+let iterations = 1;
 
 function runTests(runners: RunnerBase[]) {
     for (let i = iterations; i > 0; i--) {
@@ -39,13 +41,13 @@ let testConfigFile =
     (Harness.IO.fileExists(testconfig) ? Harness.IO.readFile(testconfig) : "");
 
 if (testConfigFile !== "") {
-    let testConfig = JSON.parse(testConfigFile);
+    const testConfig = JSON.parse(testConfigFile);
     if (testConfig.light) {
         Harness.lightMode = true;
     }
 
     if (testConfig.test && testConfig.test.length > 0) {
-        for (let option of testConfig.test) {
+        for (const option of testConfig.test) {
             if (!option) {
                 continue;
             }
@@ -68,10 +70,10 @@ if (testConfigFile !== "") {
                 case "fourslash-shims":
                     runners.push(new FourSlashRunner(FourSlashTestType.Shims));
                     break;
-                case 'fourslash-shims-pp':
+                case "fourslash-shims-pp":
                     runners.push(new FourSlashRunner(FourSlashTestType.ShimsWithPreprocess));
                     break;
-                case 'fourslash-server':
+                case "fourslash-server":
                     runners.push(new FourSlashRunner(FourSlashTestType.Server));
                     break;
                 case "fourslash-generated":

src/harness/runnerbase.ts

@@ -25,14 +25,14 @@ abstract class RunnerBase {
         let fixedPath = path;
 
         // full paths either start with a drive letter or / for *nix, shouldn't have \ in the path at this point
-        let fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g; 
-        let fullPathList = fixedPath.match(fullPath);
+        const fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g;
+        const fullPathList = fixedPath.match(fullPath);
         if (fullPathList) {
             fullPathList.forEach((match: string) => fixedPath = fixedPath.replace(match, Harness.Path.getFileName(match)));
         }
-        
+
         // when running in the browser the 'full path' is the host name, shows up in error baselines
-        let localHost = /http:\/localhost:\d+/g;
+        const localHost = /http:\/localhost:\d+/g;
         fixedPath = fixedPath.replace(localHost, "");
         return fixedPath;
     }

src/harness/rwcRunner.ts

@@ -2,12 +2,13 @@
 /// <reference path="runnerbase.ts" />
 /// <reference path="loggedIO.ts" />
 /// <reference path="..\compiler\commandLineParser.ts"/>
+/* tslint:disable:no-null */
 
-module RWC {
+namespace RWC {
     function runWithIOLog(ioLog: IOLog, fn: (oldIO: Harness.IO) => void) {
-        let oldIO = Harness.IO;
+        const oldIO = Harness.IO;
 
-        let wrappedIO = Playback.wrapIO(oldIO);
+        const wrappedIO = Playback.wrapIO(oldIO);
         wrappedIO.startReplayFromData(ioLog);
         Harness.IO = wrappedIO;
 
@@ -19,10 +20,15 @@ module RWC {
         }
     }
 
+    function isTsConfigFile(file: { path: string }): boolean {
+        const tsConfigFileName = "tsconfig.json";
+        return file.path.substr(file.path.length - tsConfigFileName.length).toLowerCase() === tsConfigFileName;
+    }
+
     export function runRWCTest(jsonPath: string) {
         describe("Testing a RWC project: " + jsonPath, () => {
-            let inputFiles: { unitName: string; content: string; }[] = [];
-            let otherFiles: { unitName: string; content: string; }[] = [];
+            let inputFiles: Harness.Compiler.TestFile[] = [];
+            let otherFiles: Harness.Compiler.TestFile[] = [];
             let compilerResult: Harness.Compiler.CompilerResult;
             let compilerOptions: ts.CompilerOptions;
             let baselineOpts: Harness.Baseline.BaselineOptions = {
@@ -49,10 +55,9 @@ module RWC {
             });
 
             it("can compile", () => {
-                let harnessCompiler = Harness.Compiler.getCompiler();
                 let opts: ts.ParsedCommandLine;
 
-                let ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
+                const ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
                 currentDirectory = ioLog.currentDirectory;
                 useCustomLibraryFile = ioLog.useCustomLibraryFile;
                 runWithIOLog(ioLog, () => {
@@ -65,19 +70,32 @@ module RWC {
                 });
 
                 runWithIOLog(ioLog, oldIO => {
-                    harnessCompiler.reset();
+                    let fileNames = opts.fileNames;
+
+                    const tsconfigFile = ts.forEach(ioLog.filesRead, f => isTsConfigFile(f) ? f : undefined);
+                    if (tsconfigFile) {
+                        const tsconfigFileContents = getHarnessCompilerInputUnit(tsconfigFile.path);
+                        const parsedTsconfigFileContents = ts.parseConfigFileTextToJson(tsconfigFile.path, tsconfigFileContents.content);
+                        const configParseResult = ts.parseJsonConfigFileContent(parsedTsconfigFileContents.config, Harness.IO, ts.getDirectoryPath(tsconfigFile.path));
+                        fileNames = configParseResult.fileNames;
+                        opts.options = ts.extend(opts.options, configParseResult.options);
+                    }
 
                     // Load the files
-                    ts.forEach(opts.fileNames, fileName => {
+                    for (const fileName of fileNames) {
                         inputFiles.push(getHarnessCompilerInputUnit(fileName));
-                    });
+                    }
 
                     // Add files to compilation
-                    let isInInputList = (resolvedPath: string) => (inputFile: { unitName: string; content: string; }) => inputFile.unitName === resolvedPath;
-                    for (let fileRead of ioLog.filesRead) {
+                    const isInInputList = (resolvedPath: string) => (inputFile: { unitName: string; content: string; }) => inputFile.unitName === resolvedPath;
+                    for (const fileRead of ioLog.filesRead) {
                         // Check if the file is already added into the set of input files.
                         const resolvedPath = ts.normalizeSlashes(Harness.IO.resolvePath(fileRead.path));
-                        let inInputList = ts.forEach(inputFiles, isInInputList(resolvedPath));
+                        const inInputList = ts.forEach(inputFiles, isInInputList(resolvedPath));
+
+                        if (isTsConfigFile(fileRead)) {
+                            continue;
+                        }
 
                         if (!Harness.isLibraryFile(fileRead.path)) {
                             if (inInputList) {
@@ -85,7 +103,7 @@ module RWC {
                             }
                             otherFiles.push(getHarnessCompilerInputUnit(fileRead.path));
                         }
-                        else if (!opts.options.noLib && Harness.isLibraryFile(fileRead.path)){
+                        else if (!opts.options.noLib && Harness.isLibraryFile(fileRead.path)) {
                             if (!inInputList) {
                                 // If useCustomLibraryFile is true, we will use lib.d.ts from json object
                                 // otherwise use the lib.d.ts from built/local
@@ -107,18 +125,22 @@ module RWC {
                     opts.options.noLib = true;
 
                     // Emit the results
-                    compilerOptions = harnessCompiler.compileFiles(
+                    compilerOptions = null;
+                    const output = Harness.Compiler.compileFiles(
                         inputFiles,
                         otherFiles,
-                        newCompilerResults => { compilerResult = newCompilerResults; },
-                        /*settingsCallback*/ undefined, opts.options,
+                        /* harnessOptions */ undefined,
+                        opts.options,
                         // Since each RWC json file specifies its current directory in its json file, we need
                         // to pass this information in explicitly instead of acquiring it from the process.
                         currentDirectory);
+
+                    compilerOptions = output.options;
+                    compilerResult = output.result;
                 });
 
-                function getHarnessCompilerInputUnit(fileName: string) {
-                    let unitName = ts.normalizeSlashes(Harness.IO.resolvePath(fileName));
+                function getHarnessCompilerInputUnit(fileName: string): Harness.Compiler.TestFile {
+                    const unitName = ts.normalizeSlashes(Harness.IO.resolvePath(fileName));
                     let content: string = null;
                     try {
                         content = Harness.IO.readFile(unitName);
@@ -180,8 +202,9 @@ module RWC {
             it("has the expected errors in generated declaration files", () => {
                 if (compilerOptions.declaration && !compilerResult.errors.length) {
                     Harness.Baseline.runBaseline("has the expected errors in generated declaration files", baseName + ".dts.errors.txt", () => {
-                        let declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult,
-                            /*settingscallback*/ undefined, compilerOptions, currentDirectory);
+                        const declFileCompilationResult = Harness.Compiler.compileDeclarationFiles(
+                            inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
+
                         if (declFileCompilationResult.declResult.errors.length === 0) {
                             return null;
                         }
@@ -206,7 +229,7 @@ class RWCRunner extends RunnerBase {
      */
     public initializeTests(): void {
         // Read in and evaluate the test list
-        let testList = Harness.IO.listFiles(RWCRunner.sourcePath, /.+\.json$/);
+        const testList = Harness.IO.listFiles(RWCRunner.sourcePath, /.+\.json$/);
         for (let i = 0; i < testList.length; i++) {
             this.runTest(testList[i]);
         }

src/harness/sourceMapRecorder.ts

@@ -15,14 +15,14 @@
 
 ///<reference path="harness.ts"/>
 
-module Harness.SourceMapRecoder {
+namespace Harness.SourceMapRecoder {
 
     interface SourceMapSpanWithDecodeErrors {
         sourceMapSpan: ts.SourceMapSpan;
         decodeErrors: string[];
     }
 
-    module SourceMapDecoder {
+    namespace SourceMapDecoder {
         let sourceMapMappings: string;
         let sourceMapNames: string[];
         let decodingIndex: number;
@@ -92,7 +92,7 @@ module Harness.SourceMapRecoder {
                     }
 
                     // 6 digit number
-                    let currentByte = base64FormatDecode();
+                    const currentByte = base64FormatDecode();
 
                     // If msb is set, we still have more bits to continue
                     moreDigits = (currentByte & 32) !== 0;
@@ -190,7 +190,7 @@ module Harness.SourceMapRecoder {
                 return { error: errorDecodeOfEncodedMapping, sourceMapSpan: decodeOfEncodedMapping };
             }
 
-            createErrorIfCondition(true, "No encoded entry found");
+            createErrorIfCondition(/*condition*/ true, "No encoded entry found");
         }
 
         export function hasCompletedDecoding() {
@@ -202,7 +202,7 @@ module Harness.SourceMapRecoder {
         }
     }
 
-    module SourceMapSpanWriter {
+    namespace SourceMapSpanWriter {
         let sourceMapRecoder: Compiler.WriterAggregator;
         let sourceMapSources: string[];
         let sourceMapNames: string[];
@@ -259,7 +259,7 @@ module Harness.SourceMapRecoder {
 
         export function recordSourceMapSpan(sourceMapSpan: ts.SourceMapSpan) {
             // verify the decoded span is same as the new span
-            let decodeResult = SourceMapDecoder.decodeNextEncodedSourceMapSpan();
+            const decodeResult = SourceMapDecoder.decodeNextEncodedSourceMapSpan();
             let decodedErrors: string[];
             if (decodeResult.error
                 || decodeResult.sourceMapSpan.emittedLine   !== sourceMapSpan.emittedLine
@@ -317,8 +317,8 @@ module Harness.SourceMapRecoder {
         }
 
         function getTextOfLine(line: number, lineMap: number[], code: string) {
-            let startPos = lineMap[line];
-            let endPos = lineMap[line + 1];
+            const startPos = lineMap[line];
+            const endPos = lineMap[line + 1];
             return code.substring(startPos, endPos);
         }
 
@@ -329,7 +329,7 @@ module Harness.SourceMapRecoder {
         }
 
         function writeRecordedSpans() {
-            let markerIds: string[] = [];
+            const markerIds: string[] = [];
 
             function getMarkerId(markerIndex: number) {
                 let markerId = "";
@@ -364,7 +364,7 @@ module Harness.SourceMapRecoder {
             }
 
             function writeSourceMapMarker(currentSpan: SourceMapSpanWithDecodeErrors, index: number, endColumn = currentSpan.sourceMapSpan.emittedColumn, endContinues?: boolean) {
-                let markerId = getMarkerId(index);
+                const markerId = getMarkerId(index);
                 markerIds.push(markerId);
 
                 writeSourceMapIndent(prevEmittedCol, markerId);
@@ -380,7 +380,7 @@ module Harness.SourceMapRecoder {
             }
 
             function writeSourceMapSourceText(currentSpan: SourceMapSpanWithDecodeErrors, index: number) {
-                let sourcePos = tsLineMap[currentSpan.sourceMapSpan.sourceLine - 1] + (currentSpan.sourceMapSpan.sourceColumn - 1);
+                const sourcePos = tsLineMap[currentSpan.sourceMapSpan.sourceLine - 1] + (currentSpan.sourceMapSpan.sourceColumn - 1);
                 let sourceText = "";
                 if (prevWrittenSourcePos < sourcePos) {
                     // Position that goes forward, get text
@@ -395,7 +395,7 @@ module Harness.SourceMapRecoder {
                     }
                 }
 
-                let tsCodeLineMap = ts.computeLineStarts(sourceText);
+                const tsCodeLineMap = ts.computeLineStarts(sourceText);
                 for (let i = 0; i < tsCodeLineMap.length; i++) {
                     writeSourceMapIndent(prevEmittedCol, i === 0 ? markerIds[index] : "  >");
                     sourceMapRecoder.Write(getTextOfLine(i, tsCodeLineMap, sourceText));
@@ -412,7 +412,7 @@ module Harness.SourceMapRecoder {
             }
 
             if (spansOnSingleLine.length) {
-                let currentJsLine = spansOnSingleLine[0].sourceMapSpan.emittedLine;
+                const currentJsLine = spansOnSingleLine[0].sourceMapSpan.emittedLine;
 
                 // Write js line
                 writeJsFileLines(currentJsLine);
@@ -420,7 +420,7 @@ module Harness.SourceMapRecoder {
                 // Emit markers
                 iterateSpans(writeSourceMapMarker);
 
-                let jsFileText = getTextOfLine(currentJsLine, jsLineMap, jsFile.code);
+                const jsFileText = getTextOfLine(currentJsLine, jsLineMap, jsFile.code);
                 if (prevEmittedCol < jsFileText.length) {
                     // There is remaining text on this line that will be part of next source span so write marker that continues
                     writeSourceMapMarker(undefined, spansOnSingleLine.length, /*endColumn*/ jsFileText.length, /*endContinues*/ true);
@@ -438,16 +438,16 @@ module Harness.SourceMapRecoder {
     }
 
     export function getSourceMapRecord(sourceMapDataList: ts.SourceMapData[], program: ts.Program, jsFiles: Compiler.GeneratedFile[]) {
-        let sourceMapRecoder = new Compiler.WriterAggregator();
+        const sourceMapRecoder = new Compiler.WriterAggregator();
 
         for (let i = 0; i < sourceMapDataList.length; i++) {
-            let sourceMapData = sourceMapDataList[i];
-            let prevSourceFile: ts.SourceFile = null;
+            const sourceMapData = sourceMapDataList[i];
+            let prevSourceFile: ts.SourceFile;
 
             SourceMapSpanWriter.intializeSourceMapSpanWriter(sourceMapRecoder, sourceMapData, jsFiles[i]);
             for (let j = 0; j < sourceMapData.sourceMapDecodedMappings.length; j++) {
-                let decodedSourceMapping = sourceMapData.sourceMapDecodedMappings[j];
-                let currentSourceFile = program.getSourceFile(sourceMapData.inputSourceFileNames[decodedSourceMapping.sourceIndex]);
+                const decodedSourceMapping = sourceMapData.sourceMapDecodedMappings[j];
+                const currentSourceFile = program.getSourceFile(sourceMapData.inputSourceFileNames[decodedSourceMapping.sourceIndex]);
                 if (currentSourceFile !== prevSourceFile) {
                     SourceMapSpanWriter.recordNewSourceFileSpan(decodedSourceMapping, currentSourceFile.text);
                     prevSourceFile = currentSourceFile;

src/harness/test262Runner.ts

@@ -1,12 +1,13 @@
 /// <reference path="harness.ts" />
 /// <reference path="runnerbase.ts" />
+/* tslint:disable:no-null */
 
 class Test262BaselineRunner extends RunnerBase {
     private static basePath = "internal/cases/test262";
     private static helpersFilePath = "tests/cases/test262-harness/helpers.d.ts";
-    private static helperFile = {
+    private static helperFile: Harness.Compiler.TestFile = {
         unitName: Test262BaselineRunner.helpersFilePath,
-        content: Harness.IO.readFile(Test262BaselineRunner.helpersFilePath)
+        content: Harness.IO.readFile(Test262BaselineRunner.helpersFilePath),
     };
     private static testFileExtensionRegex = /\.js$/;
     private static options: ts.CompilerOptions = {
@@ -30,17 +31,17 @@ class Test262BaselineRunner extends RunnerBase {
             let testState: {
                 filename: string;
                 compilerResult: Harness.Compiler.CompilerResult;
-                inputFiles: { unitName: string; content: string }[];
-                program: ts.Program;
+                inputFiles: Harness.Compiler.TestFile[];
             };
 
             before(() => {
-                let content = Harness.IO.readFile(filePath);
-                let testFilename = ts.removeFileExtension(filePath).replace(/\//g, "_") + ".test";
-                let testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, testFilename);
+                const content = Harness.IO.readFile(filePath);
+                const testFilename = ts.removeFileExtension(filePath).replace(/\//g, "_") + ".test";
+                const testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, testFilename);
 
-                let inputFiles = testCaseContent.testUnitData.map(unit => {
-                    return { unitName: Test262BaselineRunner.getTestFilePath(unit.name), content: unit.content };
+                const inputFiles: Harness.Compiler.TestFile[] = testCaseContent.testUnitData.map(unit => {
+                    const unitName = Test262BaselineRunner.getTestFilePath(unit.name);
+                    return { unitName, content: unit.content };
                 });
 
                 // Emit the results
@@ -48,13 +49,16 @@ class Test262BaselineRunner extends RunnerBase {
                     filename: testFilename,
                     inputFiles: inputFiles,
                     compilerResult: undefined,
-                    program: undefined,
                 };
 
-                Harness.Compiler.getCompiler().compileFiles([Test262BaselineRunner.helperFile].concat(inputFiles), /*otherFiles*/ [], (compilerResult, program) => {
-                    testState.compilerResult = compilerResult;
-                    testState.program = program;
-                }, /*settingsCallback*/ undefined, Test262BaselineRunner.options);
+                const output = Harness.Compiler.compileFiles(
+                    [Test262BaselineRunner.helperFile].concat(inputFiles),
+                    /*otherFiles*/ [],
+                    /* harnessOptions */ undefined,
+                    Test262BaselineRunner.options,
+                    /* currentDirectory */ undefined
+                    );
+                testState.compilerResult = output.result;
             });
 
             after(() => {
@@ -63,14 +67,14 @@ class Test262BaselineRunner extends RunnerBase {
 
             it("has the expected emitted code", () => {
                 Harness.Baseline.runBaseline("has the expected emitted code", testState.filename + ".output.js", () => {
-                    let files = testState.compilerResult.files.filter(f => f.fileName !== Test262BaselineRunner.helpersFilePath);
+                    const files = testState.compilerResult.files.filter(f => f.fileName !== Test262BaselineRunner.helpersFilePath);
                     return Harness.Compiler.collateOutputs(files);
                 }, false, Test262BaselineRunner.baselineOptions);
             });
 
             it("has the expected errors", () => {
                 Harness.Baseline.runBaseline("has the expected errors", testState.filename + ".errors.txt", () => {
-                    let errors = testState.compilerResult.errors;
+                    const errors = testState.compilerResult.errors;
                     if (errors.length === 0) {
                         return null;
                     }
@@ -79,14 +83,14 @@ class Test262BaselineRunner extends RunnerBase {
                 }, false, Test262BaselineRunner.baselineOptions);
             });
 
-            it("satisfies inletiants", () => {
-                let sourceFile = testState.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
+            it("satisfies invariants", () => {
+                const sourceFile = testState.compilerResult.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
                 Utils.assertInvariants(sourceFile, /*parent:*/ undefined);
             });
 
             it("has the expected AST", () => {
                 Harness.Baseline.runBaseline("has the expected AST", testState.filename + ".AST.txt", () => {
-                    let sourceFile = testState.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
+                    const sourceFile = testState.compilerResult.program.getSourceFile(Test262BaselineRunner.getTestFilePath(testState.filename));
                     return Utils.sourceFileToJSON(sourceFile);
                 }, false, Test262BaselineRunner.baselineOptions);
             });
@@ -96,7 +100,7 @@ class Test262BaselineRunner extends RunnerBase {
     public initializeTests() {
         // this will set up a series of describe/it blocks to run between the setup and cleanup phases
         if (this.tests.length === 0) {
-            let testFiles = this.enumerateFiles(Test262BaselineRunner.basePath, Test262BaselineRunner.testFileExtensionRegex, { recursive: true });
+            const testFiles = this.enumerateFiles(Test262BaselineRunner.basePath, Test262BaselineRunner.testFileExtensionRegex, { recursive: true });
             testFiles.forEach(fn => {
                 this.runTest(ts.normalizePath(fn));
             });

src/harness/typeWriter.ts

@@ -21,7 +21,7 @@ class TypeWriterWalker {
     }
 
     public getTypeAndSymbols(fileName: string): TypeWriterResult[] {
-        let sourceFile = this.program.getSourceFile(fileName);
+        const sourceFile = this.program.getSourceFile(fileName);
         this.currentSourceFile = sourceFile;
         this.results = [];
         this.visitNode(sourceFile);
@@ -37,27 +37,29 @@ class TypeWriterWalker {
     }
 
     private logTypeAndSymbol(node: ts.Node): void {
-        let actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
-        let lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
-        let sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
+        const actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
+        const lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
+        const sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
 
         // Workaround to ensure we output 'C' instead of 'typeof C' for base class expressions
         // let type = this.checker.getTypeAtLocation(node);
-        let type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node);
+        const type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node);
 
         ts.Debug.assert(type !== undefined, "type doesn't exist");
-        let symbol = this.checker.getSymbolAtLocation(node);
+        const symbol = this.checker.getSymbolAtLocation(node);
 
-        let typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
+        const typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation);
         let symbolString: string;
         if (symbol) {
             symbolString = "Symbol(" + this.checker.symbolToString(symbol, node.parent);
             if (symbol.declarations) {
-                for (let declaration of symbol.declarations) {
+                for (const declaration of symbol.declarations) {
                     symbolString += ", ";
-                    let declSourceFile = declaration.getSourceFile();
-                    let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
-                    symbolString += `Decl(${ ts.getBaseFileName(declSourceFile.fileName) }, ${ declLineAndCharacter.line }, ${ declLineAndCharacter.character })`;
+                    const declSourceFile = declaration.getSourceFile();
+                    const declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos);
+                    const fileName = ts.getBaseFileName(declSourceFile.fileName);
+                    const isLibFile = /lib(.*)\.d\.ts/i.test(fileName);
+                    symbolString += `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`;
                 }
             }
             symbolString += ")";

src/lib/README.md

@@ -0,0 +1,8 @@
+# Read this!
+
+The files within this directory are used to generate `lib.d.ts` and `lib.es6.d.ts`.
+
+## Generated files
+
+Any files ending in `.generated.d.ts` aren't mean to be edited by hand.
+If you need to make changes to such files, make a change to the input files for our [library generator](https://github.com/Microsoft/TSJS-lib-generator).

src/lib/core.d.ts

@@ -1210,7 +1210,7 @@ interface ArrayBuffer {
 interface ArrayBufferConstructor {
     prototype: ArrayBuffer;
     new (byteLength: number): ArrayBuffer;
-    isView(arg: any): boolean;
+    isView(arg: any): arg is ArrayBufferView;
 }
 declare var ArrayBuffer: ArrayBufferConstructor;
 

src/lib/dom.generated.d.ts

@@ -202,8 +202,8 @@ interface AnalyserNode extends AudioNode {
     smoothingTimeConstant: number;
     getByteFrequencyData(array: Uint8Array): void;
     getByteTimeDomainData(array: Uint8Array): void;
-    getFloatFrequencyData(array: any): void;
-    getFloatTimeDomainData(array: any): void;
+    getFloatFrequencyData(array: Float32Array): void;
+    getFloatTimeDomainData(array: Float32Array): void;
 }
 
 declare var AnalyserNode: {
@@ -290,7 +290,7 @@ interface AudioBuffer {
     length: number;
     numberOfChannels: number;
     sampleRate: number;
-    getChannelData(channel: number): any;
+    getChannelData(channel: number): Float32Array;
 }
 
 declare var AudioBuffer: {
@@ -334,7 +334,7 @@ interface AudioContext extends EventTarget {
     createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode;
     createOscillator(): OscillatorNode;
     createPanner(): PannerNode;
-    createPeriodicWave(real: any, imag: any): PeriodicWave;
+    createPeriodicWave(real: Float32Array, imag: Float32Array): PeriodicWave;
     createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode;
     createStereoPanner(): StereoPannerNode;
     createWaveShaper(): WaveShaperNode;
@@ -392,7 +392,7 @@ interface AudioParam {
     linearRampToValueAtTime(value: number, endTime: number): void;
     setTargetAtTime(target: number, startTime: number, timeConstant: number): void;
     setValueAtTime(value: number, startTime: number): void;
-    setValueCurveAtTime(values: any, startTime: number, duration: number): void;
+    setValueCurveAtTime(values: Float32Array, startTime: number, duration: number): void;
 }
 
 declare var AudioParam: {
@@ -468,7 +468,7 @@ interface BiquadFilterNode extends AudioNode {
     frequency: AudioParam;
     gain: AudioParam;
     type: string;
-    getFrequencyResponse(frequencyHz: any, magResponse: any, phaseResponse: any): void;
+    getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void;
 }
 
 declare var BiquadFilterNode: {
@@ -1067,7 +1067,7 @@ declare var CanvasPattern: {
 
 interface CanvasRenderingContext2D {
     canvas: HTMLCanvasElement;
-    fillStyle: any;
+    fillStyle: string | CanvasGradient | CanvasPattern;
     font: string;
     globalAlpha: number;
     globalCompositeOperation: string;
@@ -1082,7 +1082,7 @@ interface CanvasRenderingContext2D {
     shadowColor: string;
     shadowOffsetX: number;
     shadowOffsetY: number;
-    strokeStyle: any;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
     textAlign: string;
     textBaseline: string;
     arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
@@ -2193,6 +2193,68 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
     createElement(tagName: "x-ms-webview"): MSHTMLWebViewElement;
     createElement(tagName: "xmp"): HTMLBlockElement;
     createElement(tagName: string): HTMLElement;
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "a"): SVGAElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "circle"): SVGCircleElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "clipPath"): SVGClipPathElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "componentTransferFunction"): SVGComponentTransferFunctionElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "defs"): SVGDefsElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "desc"): SVGDescElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "ellipse"): SVGEllipseElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feBlend"): SVGFEBlendElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feColorMatrix"): SVGFEColorMatrixElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feComponentTransfer"): SVGFEComponentTransferElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feComposite"): SVGFECompositeElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feConvolveMatrix"): SVGFEConvolveMatrixElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feDiffuseLighting"): SVGFEDiffuseLightingElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feDisplacementMap"): SVGFEDisplacementMapElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feDistantLight"): SVGFEDistantLightElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFlood"): SVGFEFloodElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncA"): SVGFEFuncAElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncB"): SVGFEFuncBElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncG"): SVGFEFuncGElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncR"): SVGFEFuncRElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feGaussianBlur"): SVGFEGaussianBlurElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feImage"): SVGFEImageElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feMerge"): SVGFEMergeElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feMergeNode"): SVGFEMergeNodeElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feMorphology"): SVGFEMorphologyElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feOffset"): SVGFEOffsetElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "fePointLight"): SVGFEPointLightElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feSpecularLighting"): SVGFESpecularLightingElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feSpotLight"): SVGFESpotLightElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feTile"): SVGFETileElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feTurbulence"): SVGFETurbulenceElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "filter"): SVGFilterElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "foreignObject"): SVGForeignObjectElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "g"): SVGGElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "image"): SVGImageElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "gradient"): SVGGradientElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "line"): SVGLineElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "linearGradient"): SVGLinearGradientElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "marker"): SVGMarkerElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "mask"): SVGMaskElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "path"): SVGPathElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "metadata"): SVGMetadataElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "pattern"): SVGPatternElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "polygon"): SVGPolygonElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "polyline"): SVGPolylineElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "radialGradient"): SVGRadialGradientElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "rect"): SVGRectElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "svg"): SVGSVGElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "script"): SVGScriptElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "stop"): SVGStopElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "style"): SVGStyleElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "switch"): SVGSwitchElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "symbol"): SVGSymbolElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "tspan"): SVGTSpanElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "textContent"): SVGTextContentElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "text"): SVGTextElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "textPath"): SVGTextPathElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "textPositioning"): SVGTextPositioningElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "title"): SVGTitleElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "use"): SVGUseElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "view"): SVGViewElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement
     createElementNS(namespaceURI: string, qualifiedName: string): Element;
     createExpression(expression: string, resolver: XPathNSResolver): XPathExpression;
     createNSResolver(nodeResolver: Node): XPathNSResolver;
@@ -2450,8 +2512,6 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
     importNode(importedNode: Node, deep: boolean): Node;
     msElementsFromPoint(x: number, y: number): NodeList;
     msElementsFromRect(left: number, top: number, width: number, height: number): NodeList;
-    msGetPrintDocumentForNamedFlow(flowName: string): Document;
-    msSetPrintDocumentUriForNamedFlow(flowName: string, uri: string): void;
     /**
       * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method.
       * @param url Specifies a MIME type for the document.
@@ -7016,14 +7076,12 @@ interface ImageData {
     width: number;
 }
 
-interface ImageDataConstructor {
+declare var ImageData: {
     prototype: ImageData;
     new(width: number, height: number): ImageData;
     new(array: Uint8ClampedArray, width: number, height: number): ImageData;
 }
 
-declare var ImageData: ImageDataConstructor; 
-
 interface KeyboardEvent extends UIEvent {
     altKey: boolean;
     char: string;
@@ -7273,27 +7331,6 @@ declare var MSHTMLWebViewElement: {
     new(): MSHTMLWebViewElement;
 }
 
-interface MSHeaderFooter {
-    URL: string;
-    dateLong: string;
-    dateShort: string;
-    font: string;
-    htmlFoot: string;
-    htmlHead: string;
-    page: number;
-    pageTotal: number;
-    textFoot: string;
-    textHead: string;
-    timeLong: string;
-    timeShort: string;
-    title: string;
-}
-
-declare var MSHeaderFooter: {
-    prototype: MSHeaderFooter;
-    new(): MSHeaderFooter;
-}
-
 interface MSInputMethodContext extends EventTarget {
     compositionEndOffset: number;
     compositionStartOffset: number;
@@ -7452,24 +7489,6 @@ declare var MSPointerEvent: {
     new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent;
 }
 
-interface MSPrintManagerTemplatePrinter extends MSTemplatePrinter, EventTarget {
-    percentScale: number;
-    showHeaderFooter: boolean;
-    shrinkToFit: boolean;
-    drawPreviewPage(element: HTMLElement, pageNumber: number): void;
-    endPrint(): void;
-    getPrintTaskOptionValue(key: string): any;
-    invalidatePreview(): void;
-    setPageCount(pageCount: number): void;
-    startPrint(): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
-}
-
-declare var MSPrintManagerTemplatePrinter: {
-    prototype: MSPrintManagerTemplatePrinter;
-    new(): MSPrintManagerTemplatePrinter;
-}
-
 interface MSRangeCollection {
     length: number;
     item(index: number): Range;
@@ -7517,63 +7536,6 @@ declare var MSStreamReader: {
     new(): MSStreamReader;
 }
 
-interface MSTemplatePrinter {
-    collate: boolean;
-    copies: number;
-    currentPage: boolean;
-    currentPageAvail: boolean;
-    duplex: boolean;
-    footer: string;
-    frameActive: boolean;
-    frameActiveEnabled: boolean;
-    frameAsShown: boolean;
-    framesetDocument: boolean;
-    header: string;
-    headerFooterFont: string;
-    marginBottom: number;
-    marginLeft: number;
-    marginRight: number;
-    marginTop: number;
-    orientation: string;
-    pageFrom: number;
-    pageHeight: number;
-    pageTo: number;
-    pageWidth: number;
-    selectedPages: boolean;
-    selection: boolean;
-    selectionEnabled: boolean;
-    unprintableBottom: number;
-    unprintableLeft: number;
-    unprintableRight: number;
-    unprintableTop: number;
-    usePrinterCopyCollate: boolean;
-    createHeaderFooter(): MSHeaderFooter;
-    deviceSupports(property: string): any;
-    ensurePrintDialogDefaults(): boolean;
-    getPageMarginBottom(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginBottomImportant(pageRule: CSSPageRule): boolean;
-    getPageMarginLeft(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginLeftImportant(pageRule: CSSPageRule): boolean;
-    getPageMarginRight(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginRightImportant(pageRule: CSSPageRule): boolean;
-    getPageMarginTop(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any;
-    getPageMarginTopImportant(pageRule: CSSPageRule): boolean;
-    printBlankPage(): void;
-    printNonNative(document: any): boolean;
-    printNonNativeFrames(document: any, activeFrame: boolean): void;
-    printPage(element: HTMLElement): void;
-    showPageSetupDialog(): boolean;
-    showPrintDialog(): boolean;
-    startDoc(title: string): boolean;
-    stopDoc(): void;
-    updatePageStatus(status: number): void;
-}
-
-declare var MSTemplatePrinter: {
-    prototype: MSTemplatePrinter;
-    new(): MSTemplatePrinter;
-}
-
 interface MSWebViewAsyncOperation extends EventTarget {
     error: DOMError;
     oncomplete: (ev: Event) => any;
@@ -7991,6 +7953,10 @@ declare var Node: {
 }
 
 interface NodeFilter {
+    acceptNode(n: Node): number;
+}
+
+declare var NodeFilter: {
     FILTER_ACCEPT: number;
     FILTER_REJECT: number;
     FILTER_SKIP: number;
@@ -8008,7 +7974,6 @@ interface NodeFilter {
     SHOW_PROCESSING_INSTRUCTION: number;
     SHOW_TEXT: number;
 }
-declare var NodeFilter: NodeFilter;
 
 interface NodeIterator {
     expandEntityReferences: boolean;
@@ -8718,7 +8683,6 @@ declare var SVGDescElement: {
 
 interface SVGElement extends Element {
     id: string;
-    className: any;
     onclick: (ev: MouseEvent) => any;
     ondblclick: (ev: MouseEvent) => any;
     onfocusin: (ev: FocusEvent) => any;
@@ -8732,6 +8696,7 @@ interface SVGElement extends Element {
     ownerSVGElement: SVGSVGElement;
     viewportElement: SVGElement;
     xmlbase: string;
+    className: any;
     addEventListener(type: "MSGestureChange", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -10893,7 +10858,7 @@ declare var WEBGL_depth_texture: {
 }
 
 interface WaveShaperNode extends AudioNode {
-    curve: any;
+    curve: Float32Array;
     oversample: string;
 }
 
@@ -11080,34 +11045,34 @@ interface WebGLRenderingContext {
     texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void;
     texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void;
     uniform1f(location: WebGLUniformLocation, x: number): void;
-    uniform1fv(location: WebGLUniformLocation, v: any): void;
+    uniform1fv(location: WebGLUniformLocation, v: Float32Array): void;
     uniform1i(location: WebGLUniformLocation, x: number): void;
     uniform1iv(location: WebGLUniformLocation, v: Int32Array): void;
     uniform2f(location: WebGLUniformLocation, x: number, y: number): void;
-    uniform2fv(location: WebGLUniformLocation, v: any): void;
+    uniform2fv(location: WebGLUniformLocation, v: Float32Array): void;
     uniform2i(location: WebGLUniformLocation, x: number, y: number): void;
     uniform2iv(location: WebGLUniformLocation, v: Int32Array): void;
     uniform3f(location: WebGLUniformLocation, x: number, y: number, z: number): void;
-    uniform3fv(location: WebGLUniformLocation, v: any): void;
+    uniform3fv(location: WebGLUniformLocation, v: Float32Array): void;
     uniform3i(location: WebGLUniformLocation, x: number, y: number, z: number): void;
     uniform3iv(location: WebGLUniformLocation, v: Int32Array): void;
     uniform4f(location: WebGLUniformLocation, x: number, y: number, z: number, w: number): void;
-    uniform4fv(location: WebGLUniformLocation, v: any): void;
+    uniform4fv(location: WebGLUniformLocation, v: Float32Array): void;
     uniform4i(location: WebGLUniformLocation, x: number, y: number, z: number, w: number): void;
     uniform4iv(location: WebGLUniformLocation, v: Int32Array): void;
-    uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: any): void;
-    uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: any): void;
-    uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: any): void;
+    uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void;
+    uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void;
+    uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void;
     useProgram(program: WebGLProgram): void;
     validateProgram(program: WebGLProgram): void;
     vertexAttrib1f(indx: number, x: number): void;
-    vertexAttrib1fv(indx: number, values: any): void;
+    vertexAttrib1fv(indx: number, values: Float32Array): void;
     vertexAttrib2f(indx: number, x: number, y: number): void;
-    vertexAttrib2fv(indx: number, values: any): void;
+    vertexAttrib2fv(indx: number, values: Float32Array): void;
     vertexAttrib3f(indx: number, x: number, y: number, z: number): void;
-    vertexAttrib3fv(indx: number, values: any): void;
+    vertexAttrib3fv(indx: number, values: Float32Array): void;
     vertexAttrib4f(indx: number, x: number, y: number, z: number, w: number): void;
-    vertexAttrib4fv(indx: number, values: any): void;
+    vertexAttrib4fv(indx: number, values: Float32Array): void;
     vertexAttribPointer(indx: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void;
     viewport(x: number, y: number, width: number, height: number): void;
     ACTIVE_ATTRIBUTES: number;
@@ -11871,7 +11836,6 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     locationbar: BarProp;
     menubar: BarProp;
     msAnimationStartTime: number;
-    msTemplatePrinter: MSTemplatePrinter;
     name: string;
     navigator: Navigator;
     offscreenBuffering: string | boolean;
@@ -12608,7 +12572,6 @@ interface XMLHttpRequestEventTarget {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
-
 interface NodeListOf<TNode extends Node> extends NodeList {
     length: number;
     item(index: number): TNode;
@@ -12629,8 +12592,6 @@ interface EventListenerObject {
     handleEvent(evt: Event): void;
 }
 
-declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
-
 interface MessageEventInit extends EventInit {
     data?: any;
     origin?: string;
@@ -12646,6 +12607,8 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
 interface ErrorEventHandler {
     (message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void;
 }
@@ -12706,7 +12669,6 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msAnimationStartTime: number;
-declare var msTemplatePrinter: MSTemplatePrinter;
 declare var name: string;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;

src/lib/es6.d.ts

@@ -125,7 +125,34 @@ interface ObjectConstructor {
       * Copy the values of all of the enumerable own properties from one or more source objects to a 
       * target object. Returns the target object.
       * @param target The target object to copy to.
-      * @param sources One or more source objects to copy properties from.
+      * @param source The source object from which to copy properties.
+      */
+    assign<T, U>(target: T, source: U): T & U;
+
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param source1 The first source object from which to copy properties.
+      * @param source2 The second source object from which to copy properties.
+      */
+    assign<T, U, V>(target: T, source1: U, source2: V): T & U & V;
+
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param source1 The first source object from which to copy properties.
+      * @param source2 The second source object from which to copy properties.
+      * @param source3 The third source object from which to copy properties.
+      */
+    assign<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+
+    /**
+      * Copy the values of all of the enumerable own properties from one or more source objects to a 
+      * target object. Returns the target object.
+      * @param target The target object to copy to.
+      * @param sources One or more source objects from which to copy properties
       */
     assign(target: any, ...sources: any[]): any;
 

src/lib/intl.d.ts

@@ -41,7 +41,7 @@ declare module Intl {
         currency?: string;
         currencyDisplay?: string;
         useGrouping?: boolean;
-        minimumintegerDigits?: number;
+        minimumIntegerDigits?: number;
         minimumFractionDigits?: number;
         maximumFractionDigits?: number;
         minimumSignificantDigits?: number;
@@ -54,7 +54,7 @@ declare module Intl {
         style: string;
         currency?: string;
         currencyDisplay?: string;
-        minimumintegerDigits: number;
+        minimumIntegerDigits: number;
         minimumFractionDigits: number;
         maximumFractionDigits: number;
         minimumSignificantDigits?: number;

src/lib/webworker.generated.d.ts

@@ -17,7 +17,7 @@ interface AudioBuffer {
     length: number;
     numberOfChannels: number;
     sampleRate: number;
-    getChannelData(channel: number): any;
+    getChannelData(channel: number): Float32Array;
 }
 
 declare var AudioBuffer: {
@@ -465,14 +465,12 @@ interface ImageData {
     width: number;
 }
 
-interface ImageDataConstructor {
+declare var ImageData: {
     prototype: ImageData;
     new(width: number, height: number): ImageData;
     new(array: Uint8ClampedArray, width: number, height: number): ImageData;
 }
 
-declare var ImageData: ImageDataConstructor; 
-
 interface MSApp {
     clearTemporaryWebDataAsync(): MSAppAsyncOperation;
     createBlobFromRandomAccessStream(type: string, seeker: any): Blob;
@@ -894,7 +892,6 @@ interface WorkerUtils extends Object, WindowBase64 {
     setTimeout(handler: any, timeout?: any, ...args: any[]): number;
 }
 
-
 interface BlobPropertyBag {
     type?: string;
     endings?: string;
@@ -909,8 +906,6 @@ interface EventListenerObject {
     handleEvent(evt: Event): void;
 }
 
-declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
-
 interface MessageEventInit extends EventInit {
     data?: any;
     origin?: string;
@@ -926,6 +921,8 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+
 interface ErrorEventHandler {
     (message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void;
 }

src/server/client.ts

@@ -120,8 +120,8 @@ namespace ts.server {
             return response;
         }
 
-        openFile(fileName: string): void {
-            var args: protocol.FileRequestArgs = { file: fileName };
+        openFile(fileName: string, content?: string): void {
+            var args: protocol.OpenRequestArgs = { file: fileName, fileContent: content };
             this.processRequest(CommandNames.Open, args);
         }
 

src/server/node.d.ts

@@ -62,14 +62,14 @@ declare var SlowBuffer: {
 // Buffer class
 interface Buffer extends NodeBuffer { }
 interface BufferConstructor {
-    new (str: string, encoding ?: string): Buffer;
+    new (str: string, encoding?: string): Buffer;
     new (size: number): Buffer;
     new (size: Uint8Array): Buffer;
     new (array: any[]): Buffer;
     prototype: Buffer;
     isBuffer(obj: any): boolean;
-    byteLength(string: string, encoding ?: string): number;
-    concat(list: Buffer[], totalLength ?: number): Buffer;
+    byteLength(string: string, encoding?: string): number;
+    concat(list: Buffer[], totalLength?: number): Buffer;
 }
 declare var Buffer: BufferConstructor;
 
@@ -78,7 +78,7 @@ declare var Buffer: BufferConstructor;
 *               GLOBAL INTERFACES               *
 *                                               *
 ************************************************/
-declare module NodeJS {
+declare namespace NodeJS {
     export interface ErrnoException extends Error {
         errno?: any;
         code?: string;
@@ -245,7 +245,7 @@ interface NodeBuffer {
     fill(value: any, offset?: number, end?: number): void;
 }
 
-declare module NodeJS {
+declare namespace NodeJS {
     export interface Path {
         normalize(p: string): string;
         join(...paths: any[]): string;
@@ -258,7 +258,7 @@ declare module NodeJS {
     }
 }
 
-declare module NodeJS {
+declare namespace NodeJS {
     export interface ReadLineInstance extends EventEmitter {
         setPrompt(prompt: string, length: number): void;
         prompt(preserveCursor?: boolean): void;
@@ -280,8 +280,8 @@ declare module NodeJS {
     }
 }
 
-declare module NodeJS {
-    module events {
+declare namespace NodeJS {
+    namespace events {
         export class EventEmitter implements NodeJS.EventEmitter {
             static listenerCount(emitter: EventEmitter, event: string): number;
 
@@ -297,8 +297,8 @@ declare module NodeJS {
     }
 }
 
-declare module NodeJS {
-    module stream {
+declare namespace NodeJS {
+    namespace stream {
 
         export interface Stream extends events.EventEmitter {
             pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
@@ -397,8 +397,8 @@ declare module NodeJS {
     }
 }
 
-declare module NodeJS {
-    module fs {
+declare namespace NodeJS {
+    namespace fs {
         interface Stats {
             isFile(): boolean;
             isDirectory(): boolean;
@@ -547,8 +547,8 @@ declare module NodeJS {
     }
 }
 
-declare module NodeJS {
-    module path {
+declare namespace NodeJS {
+    namespace path {
         export function normalize(p: string): string;
         export function join(...paths: any[]): string;
         export function resolve(...pathSegments: any[]): string;
@@ -560,8 +560,8 @@ declare module NodeJS {
     }
 }
 
-declare module NodeJS {
-    module _debugger {
+declare namespace NodeJS {
+    namespace _debugger {
         export interface Packet {
             raw: string;
             headers: string[];

src/server/protocol.d.ts

@@ -16,7 +16,7 @@ declare namespace ts.server.protocol {
           */
         type: string;
     }
-    
+
     /** 
       * Client-initiated request message 
       */
@@ -31,7 +31,7 @@ declare namespace ts.server.protocol {
           */
         arguments?: any;
     }
-    
+
     /**
       * Request to reload the project structure for all the opened files 
       */
@@ -107,7 +107,7 @@ declare namespace ts.server.protocol {
       * A request to get the project information of the current file
       */
     export interface ProjectInfoRequest extends Request {
-        arguments: ProjectInfoRequestArgs
+        arguments: ProjectInfoRequestArgs;
     }
 
     /** 
@@ -200,7 +200,7 @@ declare namespace ts.server.protocol {
     /**
       * Object found in response messages defining a span of text in source code.
       */
-    export interface TextSpan { 
+    export interface TextSpan {
         /**
           * First character of the definition.
           */
@@ -261,18 +261,18 @@ declare namespace ts.server.protocol {
       * in the file at a given line and column.
       */
     export interface DocumentHighlightsRequest extends FileLocationRequest {
-        arguments: DocumentHighlightsRequestArgs
+        arguments: DocumentHighlightsRequestArgs;
     }
 
     export interface HighlightSpan extends TextSpan {
-        kind: string
+        kind: string;
     }
 
     export interface DocumentHighlightsItem {
         /**
           * File containing highlight spans.
           */
-        file: string,
+        file: string;
 
         /**
           * Spans to highlight in file.
@@ -422,76 +422,76 @@ declare namespace ts.server.protocol {
      * Editor options
      */
     export interface EditorOptions {
-      
+
         /** Number of spaces for each tab. Default value is 4. */
         tabSize?: number;
-        
+
         /** Number of spaces to indent during formatting. Default value is 4. */
         indentSize?: number;
-        
+
         /** The new line character to be used. Default value is the OS line delimiter. */
         newLineCharacter?: string;
-        
+
         /** Whether tabs should be converted to spaces. Default value is true. */
-        convertTabsToSpaces?: boolean;        
+        convertTabsToSpaces?: boolean;
     }
-        
+
     /**
      * Format options
      */
     export interface FormatOptions extends EditorOptions {
-      
+
         /** Defines space handling after a comma delimiter. Default value is true. */
         insertSpaceAfterCommaDelimiter?: boolean;
-        
+
         /** Defines space handling after a semicolon in a for statemen. Default value is true */
         insertSpaceAfterSemicolonInForStatements?: boolean;
-        
+
         /** Defines space handling after a binary operator. Default value is true. */
         insertSpaceBeforeAndAfterBinaryOperators?: boolean;
-        
+
         /** Defines space handling after keywords in control flow statement. Default value is true. */
         insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
-        
+
         /** Defines space handling after function keyword for anonymous functions. Default value is false. */
         insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
-        
+
         /** Defines space handling after opening and before closing non empty parenthesis. Default value is false. */
         insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
 
         /** Defines space handling after opening and before closing non empty brackets. Default value is false. */
         insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
-        
+
         /** Defines whether an open brace is put onto a new line for functions or not. Default value is false. */
         placeOpenBraceOnNewLineForFunctions?: boolean;
-        
+
         /** Defines whether an open brace is put onto a new line for control blocks or not. Default value is false. */
         placeOpenBraceOnNewLineForControlBlocks?: boolean;
-        
+
         /** Index operator */
-        [key:string] : string | number | boolean;
+        [key: string] : string | number | boolean;
     }
-  
+
     /**
       * Information found in a configure request.
       */
     export interface ConfigureRequestArguments {
-      
+
         /** 
           * Information about the host, for example 'Emacs 24.4' or
           * 'Sublime Text version 3075'
           */
         hostInfo?: string;
-        
+
         /**
           * If present, tab settings apply only to this file.
           */
         file?: string;
-        
+
         /**
          * The format options to use during formatting and other code editing features.
          */
-        formatOptions?: FormatOptions;        
+        formatOptions?: FormatOptions;
     }
 
     /**
@@ -513,6 +513,11 @@ declare namespace ts.server.protocol {
       *  Information found in an "open" request.
       */
     export interface OpenRequestArgs extends FileRequestArgs {
+        /**
+         * Used when a version of the file content is known to be more up to date than the one on disk. 
+         * Then the known content will be used upon opening instead of the disk copy   
+         */
+        fileContent?: string;
     }
 
     /**
@@ -561,27 +566,27 @@ declare namespace ts.server.protocol {
           * The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
           */
         kind: string;
-        
+
         /**
           * Optional modifiers for the kind (such as 'public').
           */
         kindModifiers: string;
-        
+
         /**
           * Starting file location of symbol.
           */
         start: Location;
-        
+
         /**
           * One past last character of symbol.
           */
         end: Location;
-        
+
         /**
           * Type and kind of symbol.
           */
         displayString: string;
-        
+
         /**
           * Documentation associated with symbol.
           */
@@ -603,7 +608,7 @@ declare namespace ts.server.protocol {
           * Last line of range for which to format text in file.
           */
         endLine: number;
-        
+
         /**
           * Character offset on last line of range for which to format text in file.
           */
@@ -619,7 +624,7 @@ declare namespace ts.server.protocol {
       */
     export interface FormatRequest extends FileLocationRequest {
         arguments: FormatRequestArgs;
-    } 
+    }
 
     /**
       * Object found in response messages defining an editing
@@ -638,7 +643,7 @@ declare namespace ts.server.protocol {
           * One character past last character of the text span to edit.
           */
         end: Location;
-        
+
         /**
           * Replace the span defined above with this string (may be
           * the empty string).
@@ -723,7 +728,7 @@ declare namespace ts.server.protocol {
           * Text of an item describing the symbol.
           */
         text: string;
-        
+
         /**
           * The symbol's kind (such as 'className' or 'parameterName' or plain 'text').
           */
@@ -773,7 +778,7 @@ declare namespace ts.server.protocol {
           * Display parts of the symbol (similar to quick info).
           */
         displayParts: SymbolDisplayPart[];
-        
+
         /**
           * Documentation strings for the symbol.
           */
@@ -790,94 +795,94 @@ declare namespace ts.server.protocol {
 
     /**
      * Signature help information for a single parameter    
-     */    
+     */
     export interface SignatureHelpParameter {
-        
+
         /**
          * The parameter's name
-         */        
+         */
         name: string;
-                
+
         /**
           * Documentation of the parameter.
           */
         documentation: SymbolDisplayPart[];
-                
+
         /**
           * Display parts of the parameter.
           */
         displayParts: SymbolDisplayPart[];
-                
+
         /**
          * Whether the parameter is optional or not.         
-         */        
+         */
         isOptional: boolean;
     }
-        
+
     /**
      * Represents a single signature to show in signature help.    
-     */    
+     */
     export interface SignatureHelpItem {
-      
+
         /**
          * Whether the signature accepts a variable number of arguments. 
-         */        
+         */
         isVariadic: boolean;
-        
+
         /**
          * The prefix display parts.
-         */        
+         */
         prefixDisplayParts: SymbolDisplayPart[];
-        
+
         /**
          * The suffix disaply parts.
-         */        
+         */
         suffixDisplayParts: SymbolDisplayPart[];
-        
+
         /**
          * The separator display parts.
-         */        
+         */
         separatorDisplayParts: SymbolDisplayPart[];
-        
+
         /**
          * The signature helps items for the parameters. 
-         */        
+         */
         parameters: SignatureHelpParameter[];
-                
+
         /**
          * The signature's documentation
          */
         documentation: SymbolDisplayPart[];
     }
-    
+
     /**
      * Signature help items found in the response of a signature help request.
      */
     export interface SignatureHelpItems {
-      
+
         /**
          * The signature help items.    
-         */        
+         */
         items: SignatureHelpItem[];
-                
+
         /**
          * The span for which signature help should appear on a signature 
-         */        
+         */
         applicableSpan: TextSpan;
-                
+
         /**
          * The item selected in the set of available help items. 
-         */        
+         */
         selectedItemIndex: number;
-                
+
         /**
          * The argument selected in the set of parameters.
-         */        
+         */
         argumentIndex: number;
-        
+
         /**
          * The argument count
-         */        
+         */
         argumentCount: number;
     }
 
@@ -885,9 +890,9 @@ declare namespace ts.server.protocol {
      * Arguments of a signature help request.
      */
     export interface SignatureHelpRequestArgs extends FileLocationRequestArgs {
-      
+
     }
-    
+
     /**
       * Signature help request; value of command field is "signatureHelp".
       * Given a file location (file, line, col), return the signature 
@@ -899,7 +904,7 @@ declare namespace ts.server.protocol {
 
     /**
      * Repsonse object for a SignatureHelpRequest.
-     */  
+     */
     export interface SignatureHelpResponse extends Response {
         body?: SignatureHelpItems;
     }
@@ -926,9 +931,9 @@ declare namespace ts.server.protocol {
       * it request for every file in this project.
       */
     export interface GeterrForProjectRequest extends Request {
-        arguments: GeterrForProjectRequestArgs
+        arguments: GeterrForProjectRequestArgs;
     }
-    
+
     /**
       * Arguments for geterr messages.
       */
@@ -968,12 +973,12 @@ declare namespace ts.server.protocol {
           * Starting file location at which text appies.
           */
         start: Location;
-        
+
         /**
           * The last file location at which the text applies.
           */
         end: Location;
-        
+
         /**
           * Text of diagnostic message.
           */
@@ -985,7 +990,7 @@ declare namespace ts.server.protocol {
           * The file for which diagnostic information is reported.
           */
         file: string;
-      
+
         /**
           * An array of diagnostic information items.
           */
@@ -999,7 +1004,7 @@ declare namespace ts.server.protocol {
     export interface DiagnosticEvent extends Event {
         body?: DiagnosticEventBody;
     }
- 
+
     /**
       * Arguments for reload request.
       */
@@ -1083,12 +1088,12 @@ declare namespace ts.server.protocol {
           * The symbol's name.
           */
         name: string;
-       
+
         /**
           * The symbol's kind (such as 'className' or 'parameterName').
           */
         kind: string;
-        
+
         /**
           * exact, substring, or prefix.
           */
@@ -1098,39 +1103,39 @@ declare namespace ts.server.protocol {
           * If this was a case sensitive or insensitive match.
           */
         isCaseSensitive?: boolean;
-        
+
         /**
           * Optional modifiers for the kind (such as 'public').
           */
         kindModifiers?: string;
-        
+
         /** 
           * The file in which the symbol is found.
           */
         file: string;
-        
+
         /**
           * The location within file at which the symbol is found.
           */
         start: Location;
-        
+
         /**
           * One past the last character of the symbol.
           */
         end: Location;
-        
+
         /**
           * Name of symbol's container symbol (if any); for example,
           * the class name if symbol is a class member.
           */
         containerName?: string;
-        
+
         /**
           * Kind of symbol's container symbol (if any).
           */
         containerKind?: string;
     }
-    
+
     /**
       * Navto response message. Body is an array of navto items.  Each
       * item gives a symbol that matched the search term.
@@ -1208,7 +1213,7 @@ declare namespace ts.server.protocol {
         childItems?: NavigationBarItem[];
     }
 
-    export interface NavBarResponse extends Response { 
+    export interface NavBarResponse extends Response {
         body?: NavigationBarItem[];
     }
 }

src/server/server.ts

@@ -1,17 +1,19 @@
 /// <reference path="node.d.ts" />
 /// <reference path="session.ts" />
+// used in fs.writeSync
+/* tslint:disable:no-null */
 
 namespace ts.server {
-    var nodeproto: typeof NodeJS._debugger = require('_debugger');
-    var readline: NodeJS.ReadLine = require('readline');
-    var path: NodeJS.Path = require('path');
-    var fs: typeof NodeJS.fs = require('fs');
+    const nodeproto: typeof NodeJS._debugger = require("_debugger");
+    const readline: NodeJS.ReadLine = require("readline");
+    const path: NodeJS.Path = require("path");
+    const fs: typeof NodeJS.fs = require("fs");
 
-    var rl = readline.createInterface({
+    const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
         terminal: false,
-    });  
+    });
 
     class Logger implements ts.server.Logger {
         fd = -1;
@@ -58,7 +60,7 @@ namespace ts.server {
         isVerbose() {
             return this.loggingEnabled() && (this.level == "verbose");
         }
-        
+
 
         msg(s: string, type = "Err") {
             if (this.fd < 0) {
@@ -68,7 +70,7 @@ namespace ts.server {
             }
             if (this.fd >= 0) {
                 s = s + "\n";
-                var prefix = Logger.padStringRight(type + " " + this.seq.toString(), "          ");
+                const prefix = Logger.padStringRight(type + " " + this.seq.toString(), "          ");
                 if (this.firstInGroup) {
                     s = prefix + s;
                     this.firstInGroup = false;
@@ -77,119 +79,30 @@ namespace ts.server {
                     this.seq++;
                     this.firstInGroup = true;
                 }
-                var buf = new Buffer(s);
+                const buf = new Buffer(s);
                 fs.writeSync(this.fd, buf, 0, buf.length, null);
             }
         }
     }
 
-    interface WatchedFile {
-        fileName: string;
-        callback: (fileName: string) => void;
-        mtime: Date;
-    }
-
-    class WatchedFileSet {
-        private watchedFiles: WatchedFile[] = [];
-        private nextFileToCheck = 0;
-        private watchTimer: NodeJS.Timer;
-
-        // average async stat takes about 30 microseconds
-        // set chunk size to do 30 files in < 1 millisecond
-        constructor(public interval = 2500, public chunkSize = 30) {
-        }
-
-        private static copyListRemovingItem<T>(item: T, list: T[]) {
-            var copiedList: T[] = [];
-            for (var i = 0, len = list.length; i < len; i++) {
-                if (list[i] != item) {
-                    copiedList.push(list[i]);
-                }
-            }
-            return copiedList;
-        }
-
-        private static getModifiedTime(fileName: string): Date {
-            return fs.statSync(fileName).mtime;
-        }
-
-        private poll(checkedIndex: number) {
-            var watchedFile = this.watchedFiles[checkedIndex];
-            if (!watchedFile) {
-                return;
-            }
-
-            fs.stat(watchedFile.fileName,(err, stats) => {
-                if (err) {
-                    watchedFile.callback(watchedFile.fileName);
-                }
-                else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) {
-                    watchedFile.mtime = WatchedFileSet.getModifiedTime(watchedFile.fileName);
-                    watchedFile.callback(watchedFile.fileName);
-                }
-            });
-        }
-
-        // this implementation uses polling and
-        // stat due to inconsistencies of fs.watch
-        // and efficiency of stat on modern filesystems
-        private startWatchTimer() {
-            this.watchTimer = setInterval(() => {
-                var count = 0;
-                var nextToCheck = this.nextFileToCheck;
-                var firstCheck = -1;
-                while ((count < this.chunkSize) && (nextToCheck !== firstCheck)) {
-                    this.poll(nextToCheck);
-                    if (firstCheck < 0) {
-                        firstCheck = nextToCheck;
-                    }
-                    nextToCheck++;
-                    if (nextToCheck === this.watchedFiles.length) {
-                        nextToCheck = 0;
-                    }
-                    count++;
-                }
-                this.nextFileToCheck = nextToCheck;
-            }, this.interval);
-        }
-
-        addFile(fileName: string, callback: (fileName: string) => void ): WatchedFile {
-            var file: WatchedFile = {
-                fileName,
-                callback,
-                mtime: WatchedFileSet.getModifiedTime(fileName)
-            };
-
-            this.watchedFiles.push(file);
-            if (this.watchedFiles.length === 1) {
-                this.startWatchTimer();
-            }
-            return file;
-        }
-
-        removeFile(file: WatchedFile) {
-            this.watchedFiles = WatchedFileSet.copyListRemovingItem(file, this.watchedFiles);
-        }
-    } 
-
     class IOSession extends Session {
         constructor(host: ServerHost, logger: ts.server.Logger) {
             super(host, Buffer.byteLength, process.hrtime, logger);
         }
 
         exit() {
-            this.projectService.log("Exiting...","Info");
+            this.projectService.log("Exiting...", "Info");
             this.projectService.closeLog();
             process.exit(0);
         }
 
         listen() {
-            rl.on('line',(input: string) => {
-                var message = input.trim();
+            rl.on("line", (input: string) => {
+                const message = input.trim();
                 this.onMessage(message);
             });
 
-            rl.on('close',() => {
+            rl.on("close", () => {
                 this.exit();
             });
         }
@@ -201,11 +114,11 @@ namespace ts.server {
     }
 
     function parseLoggingEnvironmentString(logEnvStr: string): LogOptions {
-        var logEnv: LogOptions = {};
-        var args = logEnvStr.split(' ');
-        for (var i = 0, len = args.length; i < (len - 1); i += 2) {
-            var option = args[i];
-            var value = args[i + 1];
+        const logEnv: LogOptions = {};
+        const args = logEnvStr.split(" ");
+        for (let i = 0, len = args.length; i < (len - 1); i += 2) {
+            const option = args[i];
+            const value = args[i + 1];
             if (option && value) {
                 switch (option) {
                     case "-file":
@@ -222,11 +135,11 @@ namespace ts.server {
 
     // TSS_LOG "{ level: "normal | verbose | terse", file?: string}"
     function createLoggerFromEnv() {
-        var fileName: string = undefined;
-        var detailLevel = "normal";
-        var logEnvStr = process.env["TSS_LOG"];
+        let fileName: string = undefined;
+        let detailLevel = "normal";
+        const logEnvStr = process.env["TSS_LOG"];
         if (logEnvStr) {
-            var logEnv = parseLoggingEnvironmentString(logEnvStr);
+            const logEnv = parseLoggingEnvironmentString(logEnvStr);
             if (logEnv.file) {
                 fileName = logEnv.file;
             }
@@ -242,31 +155,32 @@ namespace ts.server {
     // This places log file in the directory containing editorServices.js
     // TODO: check that this location is writable
 
-    var logger = createLoggerFromEnv();
-    
-    // REVIEW: for now this implementation uses polling.
-    // The advantage of polling is that it works reliably
-    // on all os and with network mounted files.
-    // For 90 referenced files, the average time to detect 
-    // changes is 2*msInterval (by default 5 seconds).
-    // The overhead of this is .04 percent (1/2500) with
-    // average pause of < 1 millisecond (and max
-    // pause less than 1.5 milliseconds); question is
-    // do we anticipate reference sets in the 100s and
-    // do we care about waiting 10-20 seconds to detect
-    // changes for large reference sets? If so, do we want
-    // to increase the chunk size or decrease the interval
-    // time dynamically to match the large reference set?
-    var watchedFileSet = new WatchedFileSet();
-    ts.sys.watchFile = function (fileName, callback) {
-        var watchedFile = watchedFileSet.addFile(fileName, callback);
-        return {
-            close: () => watchedFileSet.removeFile(watchedFile)
-        }
+    const logger = createLoggerFromEnv();
 
-    };
-    var ioSession = new IOSession(ts.sys, logger);
-    process.on('uncaughtException', function(err: Error) {
+    const pending: string[] = [];
+    let canWrite = true;
+    function writeMessage(s: string) {
+        if (!canWrite) {
+            pending.push(s);
+        }
+        else {
+            canWrite = false;
+            process.stdout.write(new Buffer(s, "utf8"), setCanWriteFlagAndWriteMessageIfNecessary);
+        }
+    }
+
+    function setCanWriteFlagAndWriteMessageIfNecessary() {
+        canWrite = true;
+        if (pending.length) {
+            writeMessage(pending.shift());
+        }
+    }
+
+    // Override sys.write because fs.writeSync is not reliable on Node 4
+    ts.sys.write = (s: string) => writeMessage(s);
+
+    const ioSession = new IOSession(ts.sys, logger);
+    process.on("uncaughtException", function(err: Error) {
         ioSession.logError(err, "unknown");
     });
     // Start listening

src/services/breakpoints.ts

@@ -446,7 +446,7 @@ namespace ts.BreakpointResolver {
                         // fall through.
 
                     case SyntaxKind.CatchClause:
-                        return spanInNode(lastOrUndefined((<Block>node.parent).statements));;
+                        return spanInNode(lastOrUndefined((<Block>node.parent).statements));
 
                     case SyntaxKind.CaseBlock:
                         // breakpoint in last statement of the last clause
@@ -493,9 +493,6 @@ namespace ts.BreakpointResolver {
                     default:
                         return spanInNode(node.parent);
                 }
-
-                // Default to parent node
-                return spanInNode(node.parent);
             }
 
             function spanInColonToken(node: Node): TextSpan {

src/services/formatting/formatting.ts

@@ -681,8 +681,8 @@ namespace ts.formatting {
                 let tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos);
                 if (isTokenInRange) {
                     let rangeHasError = rangeContainsError(currentTokenInfo.token);
-                    // save prevStartLine since processRange will overwrite this value with current ones
-                    let prevStartLine = previousRangeStartLine;
+                    // save previousRange since processRange will overwrite this value with current one
+                    let savePreviousRange = previousRange;
                     lineAdded = processRange(currentTokenInfo.token, tokenStart, parent, childContextNode, dynamicIndentation);
                     if (rangeHasError) {
                         // do not indent comments\token if token range overlaps with some error
@@ -693,7 +693,9 @@ namespace ts.formatting {
                             indentToken = lineAdded;
                         }
                         else {
-                            indentToken = lastTriviaWasNewLine && tokenStart.line !== prevStartLine;
+                            // indent token only if end line of previous range does not match start line of the token
+                            const prevEndLine = savePreviousRange && sourceFile.getLineAndCharacterOfPosition(savePreviousRange.end).line;
+                            indentToken = lastTriviaWasNewLine &&  tokenStart.line !== prevEndLine;
                         }
                     }
                 }
@@ -919,8 +921,8 @@ namespace ts.formatting {
                 let lineStartPosition = getStartPositionOfLine(line, sourceFile);
                 let lineEndPosition = getEndLinePosition(line, sourceFile);
 
-                // do not trim whitespaces in comments
-                if (range && isComment(range.kind) && range.pos <= lineEndPosition && range.end > lineEndPosition) {
+                // do not trim whitespaces in comments or template expression
+                if (range && (isComment(range.kind) || isStringOrRegularExpressionOrTemplateLiteral(range.kind)) && range.pos <= lineEndPosition && range.end > lineEndPosition) {
                     continue;
                 }
 

src/services/formatting/formattingScanner.ts

@@ -3,8 +3,14 @@
 
 /* @internal */
 namespace ts.formatting {
-    let scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false);
-
+    const standardScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, LanguageVariant.Standard);
+    const jsxScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, LanguageVariant.JSX);
+    
+    /**
+     * Scanner that is currently used for formatting
+     */
+    let scanner: Scanner;
+    
     export interface FormattingScanner {
         advance(): void;
         isOnToken(): boolean;
@@ -22,6 +28,8 @@ namespace ts.formatting {
     }
 
     export function getFormattingScanner(sourceFile: SourceFile, startPos: number, endPos: number): FormattingScanner {
+        Debug.assert(scanner === undefined);
+        scanner = sourceFile.languageVariant === LanguageVariant.JSX ? jsxScanner : standardScanner;
 
         scanner.setText(sourceFile.text);
         scanner.setTextPos(startPos);
@@ -40,12 +48,17 @@ namespace ts.formatting {
             isOnToken: isOnToken,
             lastTrailingTriviaWasNewLine: () => wasNewLine,
             close: () => {
+                Debug.assert(scanner !== undefined);
+                
                 lastTokenInfo = undefined;
                 scanner.setText(undefined);
+                scanner = undefined;
             }
         }
 
         function advance(): void {
+            Debug.assert(scanner !== undefined);
+            
             lastTokenInfo = undefined;
             let isStarted = scanner.getStartPos() !== startPos;
 
@@ -138,6 +151,8 @@ namespace ts.formatting {
         }
 
         function readTokenInfo(n: Node): TokenInfo {
+            Debug.assert(scanner !== undefined);
+            
             if (!isOnToken()) {
                 // scanner is not on the token (either advance was not called yet or scanner is already past the end position)
                 return {
@@ -245,6 +260,8 @@ namespace ts.formatting {
         }
 
         function isOnToken(): boolean {
+            Debug.assert(scanner !== undefined);
+            
             let current = (lastTokenInfo && lastTokenInfo.token.kind) || scanner.getToken();
             let startPos = (lastTokenInfo && lastTokenInfo.token.pos) || scanner.getStartPos();
             return startPos < endPos && current !== SyntaxKind.EndOfFileToken && !isTrivia(current);

src/services/formatting/rules.ts

@@ -214,10 +214,13 @@ namespace ts.formatting {
         public SpaceBetweenYieldOrYieldStarAndOperand: Rule;
 
         // Async functions
+        public SpaceBetweenAsyncAndOpenParen: Rule;
         public SpaceBetweenAsyncAndFunctionKeyword: Rule;
 
-        // Tagged template string
+        // Template strings
         public SpaceBetweenTagAndTemplateString: Rule;
+        public NoSpaceAfterTemplateHeadAndMiddle: Rule;
+        public NoSpaceBeforeTemplateMiddleAndTail: Rule;
 
         constructor() {
             ///
@@ -367,10 +370,13 @@ namespace ts.formatting {
             this.SpaceBetweenYieldOrYieldStarAndOperand = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.YieldKeyword, SyntaxKind.AsteriskToken]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), RuleAction.Space));
 
             // Async-await
+            this.SpaceBetweenAsyncAndOpenParen = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsArrowFunctionContext, Rules.IsSameLineTokenContext), RuleAction.Space));
             this.SpaceBetweenAsyncAndFunctionKeyword = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.FunctionKeyword), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space));
 
             // template string
             this.SpaceBetweenTagAndTemplateString = new Rule(RuleDescriptor.create3(SyntaxKind.Identifier, Shared.TokenRange.FromTokens([SyntaxKind.NoSubstitutionTemplateLiteral, SyntaxKind.TemplateHead])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space));
+            this.NoSpaceAfterTemplateHeadAndMiddle = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete));
+            this.NoSpaceBeforeTemplateMiddleAndTail = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete));
 
             // These rules are higher in priority than user-configurable rules.
             this.HighPriorityCommonRules =
@@ -398,8 +404,8 @@ namespace ts.formatting {
                 this.NoSpaceBeforeOpenParenInFuncCall,
                 this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator,
                 this.SpaceAfterVoidOperator,
-                this.SpaceBetweenAsyncAndFunctionKeyword,
-                this.SpaceBetweenTagAndTemplateString,
+                this.SpaceBetweenAsyncAndOpenParen, this.SpaceBetweenAsyncAndFunctionKeyword,
+                this.SpaceBetweenTagAndTemplateString, this.NoSpaceAfterTemplateHeadAndMiddle, this.NoSpaceBeforeTemplateMiddleAndTail,
 
                 // TypeScript-specific rules
                 this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport,
@@ -699,6 +705,10 @@ namespace ts.formatting {
             return context.currentTokenSpan.kind !== SyntaxKind.CommaToken;
         }
 
+        static IsArrowFunctionContext(context: FormattingContext): boolean {
+            return context.contextNode.kind === SyntaxKind.ArrowFunction;
+        }
+
         static IsSameLineTokenContext(context: FormattingContext): boolean {
             return context.TokensAreOnSameLine();
         }

src/services/formatting/smartIndenter.ts

@@ -13,25 +13,45 @@ namespace ts.formatting {
                 return 0; // past EOF
             }
 
+            // no indentation when the indent style is set to none,
+            // so we can return fast
+            if (options.IndentStyle === IndentStyle.None) {
+                return 0;
+            }
+
             let precedingToken = findPrecedingToken(position, sourceFile);
             if (!precedingToken) {
                 return 0;
             }
 
             // no indentation in string \regex\template literals
-            let precedingTokenIsLiteral =
-                precedingToken.kind === SyntaxKind.StringLiteral ||
-                precedingToken.kind === SyntaxKind.RegularExpressionLiteral ||
-                precedingToken.kind === SyntaxKind.NoSubstitutionTemplateLiteral ||
-                precedingToken.kind === SyntaxKind.TemplateHead ||
-                precedingToken.kind === SyntaxKind.TemplateMiddle ||
-                precedingToken.kind === SyntaxKind.TemplateTail;
+            let precedingTokenIsLiteral = isStringOrRegularExpressionOrTemplateLiteral(precedingToken.kind);
             if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) {
                 return 0;
             }
 
             let lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
 
+            // indentation is first non-whitespace character in a previous line
+            // for block indentation, we should look for a line which contains something that's not
+            // whitespace.
+            if (options.IndentStyle === IndentStyle.Block) {
+
+                // move backwards until we find a line with a non-whitespace character,
+                // then find the first non-whitespace character for that line.
+                let current = position;
+                while (current > 0){
+                    let char = sourceFile.text.charCodeAt(current);
+                    if (!isWhiteSpace(char) && !isLineBreak(char)) {
+                        break;
+                    }
+                    current--;
+                }
+
+                let lineStart = ts.getLineStartPositionForPosition(current, sourceFile);
+                return SmartIndenter.findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options);
+            }
+
             if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) {
                 // previous token is comma that separates items in list - find the previous item and try to derive indentation from it
                 let actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options);
@@ -224,7 +244,7 @@ namespace ts.formatting {
         function getStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter {
             return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
         }
-        
+
         export function childStartsOnTheSameLineWithElseInIfStatement(parent: Node, child: TextRangeWithKind, childStartLine: number, sourceFile: SourceFile): boolean {
             if (parent.kind === SyntaxKind.IfStatement && (<IfStatement>parent).elseStatement === child) {
                 let elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile);
@@ -325,7 +345,7 @@ namespace ts.formatting {
             }
 
             return Value.Unknown;
-            
+
             function getStartingExpression(node: PropertyAccessExpression | CallExpression | ElementAccessExpression) {
                 while (true) {
                     switch (node.kind) {
@@ -340,7 +360,6 @@ namespace ts.formatting {
                             return node;
                     }
                 }
-                return node;
             }
         }
 
@@ -405,6 +424,7 @@ namespace ts.formatting {
 
         function nodeContentIsAlwaysIndented(kind: SyntaxKind): boolean {
             switch (kind) {
+                case SyntaxKind.ExpressionStatement:
                 case SyntaxKind.ClassDeclaration:
                 case SyntaxKind.ClassExpression:
                 case SyntaxKind.InterfaceDeclaration:
@@ -487,4 +507,4 @@ namespace ts.formatting {
             return !nodeWillIndentChild(parent, child, true);
         }
     }
-}
+}

src/services/formatting/tokenRange.ts

@@ -14,7 +14,7 @@ namespace ts.formatting {
             constructor(from: SyntaxKind, to: SyntaxKind, except: SyntaxKind[]) {
                 this.tokens = [];
                 for (let token = from; token <= to; token++) {
-                    if (except.indexOf(token) < 0) {
+                    if (ts.indexOf(except, token) < 0) {
                         this.tokens.push(token);
                     }
                 }
@@ -123,4 +123,4 @@ namespace ts.formatting {
             static TypeNames = TokenRange.FromTokens([SyntaxKind.Identifier, SyntaxKind.NumberKeyword, SyntaxKind.StringKeyword, SyntaxKind.BooleanKeyword, SyntaxKind.SymbolKeyword, SyntaxKind.VoidKeyword, SyntaxKind.AnyKeyword]);
         }
     }
-}
+}

src/services/navigateTo.ts

@@ -6,6 +6,9 @@ namespace ts.NavigateTo {
         let patternMatcher = createPatternMatcher(searchValue);
         let rawItems: RawNavigateToItem[] = [];
 
+        // This means "compare in a case insensitive manner."
+        let baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" };
+
         // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] 
         forEach(program.getSourceFiles(), sourceFile => {
             cancellationToken.throwIfCancellationRequested();
@@ -162,8 +165,6 @@ namespace ts.NavigateTo {
             return bestMatchKind;
         }
 
-        // This means "compare in a case insensitive manner."
-        let baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" };
         function compareNavigateToItems(i1: RawNavigateToItem, i2: RawNavigateToItem) {
             // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
             // Right now we just sort by kind first, and then by name of the item.

src/services/navigationBar.ts

@@ -2,7 +2,7 @@
 
 /* @internal */
 namespace ts.NavigationBar {
-    export function getNavigationBarItems(sourceFile: SourceFile): ts.NavigationBarItem[]  {
+    export function getNavigationBarItems(sourceFile: SourceFile, compilerOptions: CompilerOptions): ts.NavigationBarItem[]  {
         // If the source file has any child items, then it included in the tree
         // and takes lexical ownership of all other top-level items.
         let hasGlobalNode = false;

src/services/shims.ts

@@ -273,7 +273,7 @@ namespace ts {
         private loggingEnabled = false;
         private tracingEnabled = false;
         
-        public resolveModuleNames: (moduleName: string[], containingFile: string) => string[];
+        public resolveModuleNames: (moduleName: string[], containingFile: string) => ResolvedModule[];
         
         constructor(private shimHost: LanguageServiceShimHost) {
             // if shimHost is a COM object then property check will become method call with no arguments.
@@ -281,7 +281,10 @@ namespace ts {
             if ("getModuleResolutionsForFile" in this.shimHost) {
                 this.resolveModuleNames = (moduleNames: string[], containingFile: string) => {
                     let resolutionsInFile = <Map<string>>JSON.parse(this.shimHost.getModuleResolutionsForFile(containingFile));
-                    return map(moduleNames, name => lookUp(resolutionsInFile, name));
+                    return map(moduleNames, name => {
+                        const result = lookUp(resolutionsInFile, name);
+                        return result ? { resolvedFileName: result } : undefined;
+                    });
                 };
             }
         }
@@ -320,7 +323,6 @@ namespace ts {
             // TODO: should this be '==='?
             if (settingsJson == null || settingsJson == "") {
                 throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
-                return null;
             }
             return <CompilerOptions>JSON.parse(settingsJson);
         }
@@ -942,7 +944,11 @@ namespace ts {
         public resolveModuleName(fileName: string, moduleName: string, compilerOptionsJson: string): string {
             return this.forwardJSONCall(`resolveModuleName('${fileName}')`, () => {
                 let compilerOptions = <CompilerOptions>JSON.parse(compilerOptionsJson);
-                return resolveModuleName(moduleName, normalizeSlashes(fileName), compilerOptions, this.host);
+                const result = resolveModuleName(moduleName, normalizeSlashes(fileName), compilerOptions, this.host);
+                return {
+                    resolvedFileName: result.resolvedModule ? result.resolvedModule.resolvedFileName: undefined,
+                    failedLookupLocations: result.failedLookupLocations
+                };
             }); 
         }
 
@@ -950,7 +956,8 @@ namespace ts {
             return this.forwardJSONCall(
                 "getPreProcessedFileInfo('" + fileName + "')",
                 () => {
-                    var result = preProcessFile(sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength()));
+                    // for now treat files as JavaScript 
+                    var result = preProcessFile(sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength()), /* readImportFiles */ true, /* detectJavaScriptImports */ true);
                     var convertResult = {
                         referencedFiles: <IFileReference[]>[],
                         importedFiles: <IFileReference[]>[],
@@ -983,7 +990,7 @@ namespace ts {
                 () => {
                     let text = sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength());
 
-                    let result = parseConfigFileText(fileName, text);
+                    let result = parseConfigFileTextToJson(fileName, text);
 
                     if (result.error) {
                         return {
@@ -993,7 +1000,7 @@ namespace ts {
                         };
                     }
 
-                    var configFile = parseConfigFile(result.config, this.host, getDirectoryPath(normalizeSlashes(fileName)));
+                    var configFile = parseJsonConfigFileContent(result.config, this.host, getDirectoryPath(normalizeSlashes(fileName)));
 
                     return {
                         options: configFile.options,
@@ -1026,7 +1033,7 @@ namespace ts {
         public createLanguageServiceShim(host: LanguageServiceShimHost): LanguageServiceShim {
             try {
                 if (this.documentRegistry === undefined) {
-                    this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
+                    this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory());
                 }
                 var hostAdapter = new LanguageServiceShimHostAdapter(host);
                 var languageService = createLanguageService(hostAdapter, this.documentRegistry);
@@ -1062,7 +1069,7 @@ namespace ts {
         public close(): void {
             // Forget all the registered shims
             this._shims = [];
-            this.documentRegistry = createDocumentRegistry();
+            this.documentRegistry = undefined;
         }
 
         public registerShim(shim: Shim): void {

src/services/signatureHelp.ts

@@ -204,7 +204,7 @@ namespace ts.SignatureHelp {
         if (!candidates.length) {
             // We didn't have any sig help items produced by the TS compiler.  If this is a JS 
             // file, then see if we can figure out anything better.
-            if (isJavaScript(sourceFile.fileName)) {
+            if (isSourceFileJavaScript(sourceFile)) {
                 return createJavaScriptSignatureHelpItems(argumentInfo);
             }
 

src/services/utilities.ts

@@ -9,7 +9,7 @@ namespace ts {
     export function getEndLinePosition(line: number, sourceFile: SourceFile): number {
         Debug.assert(line >= 0);
         let lineStarts = sourceFile.getLineStarts();
-        
+
         let lineIndex = line;
         if (lineIndex + 1 === lineStarts.length) {
             // last line - return EOF
@@ -128,7 +128,8 @@ namespace ts {
                 return isCompletedNode((<IfStatement>n).thenStatement, sourceFile);
 
             case SyntaxKind.ExpressionStatement:
-                return isCompletedNode((<ExpressionStatement>n).expression, sourceFile);
+                return isCompletedNode((<ExpressionStatement>n).expression, sourceFile) ||
+                    hasChildOfKind(n, SyntaxKind.SemicolonToken);
 
             case SyntaxKind.ArrayLiteralExpression:
             case SyntaxKind.ArrayBindingPattern:
@@ -170,7 +171,7 @@ namespace ts {
             case SyntaxKind.VoidExpression:
             case SyntaxKind.YieldExpression:
             case SyntaxKind.SpreadElementExpression:
-                let unaryWordExpression = (<TypeOfExpression|DeleteExpression|VoidExpression|YieldExpression|SpreadElementExpression>n);
+                let unaryWordExpression = (<TypeOfExpression | DeleteExpression | VoidExpression | YieldExpression | SpreadElementExpression>n);
                 return isCompletedNode(unaryWordExpression.expression, sourceFile);
 
             case SyntaxKind.TaggedTemplateExpression:
@@ -252,7 +253,7 @@ namespace ts {
         });
 
         // Either we didn't find an appropriate list, or the list must contain us.
-        Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node)); 
+        Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node));
         return syntaxList;
     }
 
@@ -388,7 +389,7 @@ namespace ts {
                 // if this is the case - then we should assume that token in question is located in previous child.
                 if (position < child.end && (nodeHasTokens(child) || child.kind === SyntaxKind.JsxText)) {
                     const start = child.getStart(sourceFile);
-                    const lookInPreviousChild = 
+                    const lookInPreviousChild =
                         (start >= position) || // cursor in the leading trivia
                         (child.kind === SyntaxKind.JsxText && start === child.end); // whitespace only JsxText 
                     
@@ -425,7 +426,7 @@ namespace ts {
             }
         }
     }
-    
+
     export function isInString(sourceFile: SourceFile, position: number) {
         let token = getTokenAtPosition(sourceFile, position);
         return token && token.kind === SyntaxKind.StringLiteral && position > token.getStart();
@@ -473,7 +474,7 @@ namespace ts {
         let commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos);
 
         return forEach(commentRanges, jsDocPrefix);
-        
+
         function jsDocPrefix(c: CommentRange): boolean {
             var text = sourceFile.text;
             return text.length >= c.pos + 3 && text[c.pos] === '/' && text[c.pos + 1] === '*' && text[c.pos + 2] === '*';
@@ -562,6 +563,15 @@ namespace ts {
         return kind === SyntaxKind.SingleLineCommentTrivia || kind === SyntaxKind.MultiLineCommentTrivia;
     }
 
+    export function isStringOrRegularExpressionOrTemplateLiteral(kind: SyntaxKind): boolean {
+        if (kind === SyntaxKind.StringLiteral
+            || kind === SyntaxKind.RegularExpressionLiteral
+            || isTemplateLiteralKind(kind)) {
+            return true;
+        }
+        return false;
+    }
+
     export function isPunctuation(kind: SyntaxKind): boolean {
         return SyntaxKind.FirstPunctuation <= kind && kind <= SyntaxKind.LastPunctuation;
     }
@@ -626,7 +636,8 @@ namespace ts {
             increaseIndent: () => { indent++; },
             decreaseIndent: () => { indent--; },
             clear: resetWriter,
-            trackSymbol: () => { }
+            trackSymbol: () => { },
+            reportInaccessibleThisError: () => { }
         };
 
         function writeIndent() {
@@ -689,7 +700,7 @@ namespace ts {
     }
 
     export function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
-        return <SymbolDisplayPart> {
+        return <SymbolDisplayPart>{
             text: text,
             kind: SymbolDisplayPartKind[kind]
         };