Merge branch 'master' into dogfoodStringLiterals

AUTHORS.md

@@ -8,6 +8,7 @@ TypeScript is authored by:
 * Basarat Ali Syed 
 * Ben Duffield
 * Bill Ticehurst 
+* Brett Mayen
 * Bryan Forbes 
 * Caitlin Potter 
 * Chris Bubernak
@@ -17,11 +18,14 @@ TypeScript is authored by:
 * Dan Quirk 
 * Daniel Rosenwasser
 * David Li 
-* Dick van den Brink 
-* Dirk Bäumer 
+* Denis Nedelyaev
+* Dick van den Brink
+* Dirk Bäumer
+* Eyas Sharaiha
 * Frank Wallis 
 * Gabriel Isenberg
 * Gilad Peleg 
+* Graeme Wicksted
 * Guillaume Salles 
 * Harald Niesche
 * Ingvar Stepanyan
@@ -31,30 +35,39 @@ TypeScript is authored by:
 * Jason Ramsay 
 * Jed Mao
 * Johannes Rieken 
+* John Vilk
 * Jonathan Bond-Caron
 * Jonathan Park
 * Jonathan Turner
 * Josh Kalderimis
+* Julian Williams
 * Kagami Sascha Rosylight
 * Keith Mashinter
+* Ken Howard
 * Kenji Imamula
 * Lorant Pinter 
+* Martin Všetička
 * Masahiro Wakame
 * Max Deepfield
 * Micah Zoltu 
 * Mohamed Hegazy 
+* Nathan Shively-Sanders
 * Oleg Mihailik
 * Oleksandr Chekhovskyi 
 * Paul van Brenk 
 * Pedro Maltez 
 * Philip Bulley
 * piloopin
+* @progre
+* Punya Biswal
 * Ron Buckton 
 * Ryan Cavanaugh 
+* Ryohei Ikegami
+* Sébastien Arod
 * Sheetal Nandi
 * Shengping Zhong
 * Shyyko Serhiy
-* Simon Hürlimann
+* Simon Hürlimann
 * Solal Pirelli
 * Stan Thomas
 * Steve Lucco
@@ -63,8 +76,10 @@ TypeScript is authored by:
 * togru
 * Tomas Grubliauskas
 * TruongSinh Tran-Nguyen
+* Viliv Vane
 * Vladimir Matveev
 * Wesley Wigham
+* York Yao
 * Yui Tanglertsampan
 * Zev Spitz 
-* Zhengbo Li
+* Zhengbo Li

README.md

@@ -1,6 +1,6 @@
 [![Build Status](https://travis-ci.org/Microsoft/TypeScript.svg?branch=master)](https://travis-ci.org/Microsoft/TypeScript)
-[![npm version](https://badge.fury.io/js/typescript.svg)](http://badge.fury.io/js/typescript)
-[![Downloads](http://img.shields.io/npm/dm/TypeScript.svg)](https://npmjs.org/package/typescript)
+[![npm version](https://badge.fury.io/js/typescript.svg)](https://www.npmjs.com/package/typescript)
+[![Downloads](https://img.shields.io/npm/dm/TypeScript.svg)](https://www.npmjs.com/package/typescript)
 
 # TypeScript
 

package.json

@@ -35,7 +35,8 @@
         "browserify": "latest",
         "istanbul": "latest",
         "mocha-fivemat-progress-reporter": "latest",
-        "tslint": "latest",
+        "tslint": "next",
+        "typescript": "next",
         "tsd": "latest"
     },
     "scripts": {

scripts/tslint/booleanTriviaRule.ts

@@ -1,6 +1,5 @@
-/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
-/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
-
+import * as Lint from "tslint/lib/lint";
+import * as ts from "typescript";
 
 export class Rule extends Lint.Rules.AbstractRule {
     public static FAILURE_STRING_FACTORY = (name: string, currently: string) => `Tag boolean argument as '${name}' (currently '${currently}')`;
@@ -19,7 +18,7 @@ class BooleanTriviaWalker extends Lint.RuleWalker {
 
     visitCallExpression(node: ts.CallExpression) {
         super.visitCallExpression(node);
-		if (node.arguments) {
+        if (node.arguments) {
             const targetCallSignature = this.checker.getResolvedSignature(node);
             if (!!targetCallSignature) {
                 const targetParameters = targetCallSignature.getParameters();
@@ -37,7 +36,7 @@ class BooleanTriviaWalker extends Lint.RuleWalker {
                         let triviaContent: string;
                         const ranges = ts.getLeadingCommentRanges(arg.getFullText(), 0);
                         if (ranges && ranges.length === 1 && ranges[0].kind === ts.SyntaxKind.MultiLineCommentTrivia) {
-                            triviaContent = arg.getFullText().slice(ranges[0].pos + 2, ranges[0].end - 2); //+/-2 to remove /**/
+                            triviaContent = arg.getFullText().slice(ranges[0].pos + 2, ranges[0].end - 2); // +/-2 to remove /**/
                         }
                         if (triviaContent !== param.getName()) {
                             this.addFailure(this.createFailure(arg.getStart(source), arg.getWidth(source), Rule.FAILURE_STRING_FACTORY(param.getName(), triviaContent)));
@@ -45,6 +44,6 @@ class BooleanTriviaWalker extends Lint.RuleWalker {
                     }
                 }
             }
-		}			
+        }
     }
 }

scripts/tslint/nextLineRule.ts

@@ -1,5 +1,5 @@
-/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
-/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+import * as Lint from "tslint/lib/lint";
+import * as ts from "typescript";
 
 const OPTION_CATCH = "check-catch";
 const OPTION_ELSE = "check-else";

scripts/tslint/noNullRule.ts

@@ -1,5 +1,5 @@
-/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
-/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+import * as Lint from "tslint/lib/lint";
+import * as ts from "typescript";
 
 
 export class Rule extends Lint.Rules.AbstractRule {

scripts/tslint/preferConstRule.ts

@@ -1,5 +1,5 @@
-/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
-/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+import * as Lint from "tslint/lib/lint";
+import * as ts from "typescript";
 
 
 export class Rule extends Lint.Rules.AbstractRule {
@@ -101,13 +101,13 @@ class PreferConstWalker extends Lint.RuleWalker {
             this.visitBindingLiteralExpression(node as (ts.ArrayLiteralExpression | ts.ObjectLiteralExpression));
         }
     }
-    
+
     private visitBindingLiteralExpression(node: ts.ArrayLiteralExpression | ts.ObjectLiteralExpression) {
         if (node.kind === ts.SyntaxKind.ObjectLiteralExpression) {
             const pattern = node as ts.ObjectLiteralExpression;
             for (const element of pattern.properties) {
                 if (element.name.kind === ts.SyntaxKind.Identifier) {
-                    this.markAssignment(element.name as ts.Identifier)
+                    this.markAssignment(element.name as ts.Identifier);
                 }
                 else if (isBindingPattern(element.name)) {
                     this.visitBindingPatternIdentifiers(element.name as ts.BindingPattern);

scripts/tslint/typeOperatorSpacingRule.ts

@@ -1,5 +1,5 @@
-/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
-/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+import * as Lint from "tslint/lib/lint";
+import * as ts from "typescript";
 
 
 export class Rule extends Lint.Rules.AbstractRule {

src/compiler/binder.ts

@@ -175,9 +175,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,

src/compiler/checker.ts

@@ -81,7 +81,7 @@ namespace ts {
             symbolToString,
             getAugmentedPropertiesOfType,
             getRootSymbols,
-            getContextualType: getApparentTypeOfContextualType,
+            getContextualType,
             getFullyQualifiedName,
             getResolvedSignature,
             getConstantValue,
@@ -109,9 +109,9 @@ namespace ts {
         const undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsUndefinedOrNull, "undefined");
         const nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null");
         const unknownType = createIntrinsicType(TypeFlags.Any, "unknown");
-        const circularType = createIntrinsicType(TypeFlags.Any, "__circular__");
 
         const emptyObjectType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
+        const emptyUnionType = emptyObjectType;
         const emptyGenericType = <GenericType><ObjectType>createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
         emptyGenericType.instantiations = {};
 
@@ -122,8 +122,8 @@ namespace ts {
 
         const noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);
 
-        const anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, false, false);
-        const unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, false, false);
+        const anySignature = createSignature(undefined, undefined, emptyArray, anyType, undefined, 0, /*hasRestParameter*/ false, /*hasStringLiterals*/ false);
+        const unknownSignature = createSignature(undefined, undefined, emptyArray, unknownType, undefined, 0, /*hasRestParameter*/ false, /*hasStringLiterals*/ false);
 
         const globals: SymbolTable = {};
 
@@ -200,6 +200,10 @@ namespace ts {
             "symbol": {
                 type: esSymbolType,
                 flags: TypeFlags.ESSymbol
+            },
+            "undefined": {
+                type: undefinedType,
+                flags: TypeFlags.ContainsUndefinedOrNull
             }
         };
 
@@ -295,7 +299,12 @@ namespace ts {
                     target.constEnumOnlyModule = false;
                 }
                 target.flags |= source.flags;
-                if (!target.valueDeclaration && source.valueDeclaration) target.valueDeclaration = source.valueDeclaration;
+                if (source.valueDeclaration &&
+                    (!target.valueDeclaration ||
+                     (target.valueDeclaration.kind === SyntaxKind.ModuleDeclaration && source.valueDeclaration.kind !== SyntaxKind.ModuleDeclaration))) {
+                    // other kinds of value declarations take precedence over modules
+                    target.valueDeclaration = source.valueDeclaration;
+                }
                 forEach(source.declarations, node => {
                     target.declarations.push(node);
                 });
@@ -2267,7 +2276,7 @@ namespace ts {
                 return false;
             }
             resolutionTargets.push(target);
-            resolutionResults.push(true);
+            resolutionResults.push(/*items*/ true);
             resolutionPropertyNames.push(propertyName);
             return true;
         }
@@ -3339,7 +3348,7 @@ namespace ts {
 
         function getDefaultConstructSignatures(classType: InterfaceType): Signature[] {
             if (!hasClassBaseType(classType)) {
-                return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)];
+                return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, /*hasRestParameter*/ false, /*hasStringLiterals*/ false)];
             }
             const baseConstructorType = getBaseConstructorTypeOfClass(classType);
             const baseSignatures = getSignaturesOfType(baseConstructorType, SignatureKind.Construct);
@@ -3964,7 +3973,7 @@ namespace ts {
         }
 
         function getSignatureInstantiation(signature: Signature, typeArguments: Type[]): Signature {
-            return instantiateSignature(signature, createTypeMapper(signature.typeParameters, typeArguments), true);
+            return instantiateSignature(signature, createTypeMapper(signature.typeParameters, typeArguments), /*eraseTypeParameters*/ true);
         }
 
         function getErasedSignature(signature: Signature): Signature {
@@ -3974,7 +3983,7 @@ namespace ts {
                     signature.erasedSignatureCache = instantiateSignature(getErasedSignature(signature.target), signature.mapper);
                 }
                 else {
-                    signature.erasedSignatureCache = instantiateSignature(signature, createTypeEraser(signature.typeParameters), true);
+                    signature.erasedSignatureCache = instantiateSignature(signature, createTypeEraser(signature.typeParameters), /*eraseTypeParameters*/ true);
                 }
             }
             return signature.erasedSignatureCache;
@@ -4413,7 +4422,7 @@ namespace ts {
         // a named type that circularly references itself.
         function getUnionType(types: Type[], noSubtypeReduction?: boolean): Type {
             if (types.length === 0) {
-                return emptyObjectType;
+                return emptyUnionType;
             }
             const typeSet: Type[] = [];
             addTypesToSet(typeSet, types, TypeFlags.Union);
@@ -5090,7 +5099,7 @@ namespace ts {
                 let result = Ternary.True;
                 const sourceTypes = source.types;
                 for (const sourceType of sourceTypes) {
-                    const related = typeRelatedToSomeType(sourceType, target, false);
+                    const related = typeRelatedToSomeType(sourceType, target, /*reportErrors*/ false);
                     if (!related) {
                         return Ternary.False;
                     }
@@ -5488,7 +5497,7 @@ namespace ts {
                     const saveErrorInfo = errorInfo;
                     let related = isRelatedTo(s, t, reportErrors);
                     if (!related) {
-                        related = isRelatedTo(t, s, false);
+                        related = isRelatedTo(t, s, /*reportErrors*/ false);
                         if (!related) {
                             if (reportErrors) {
                                 reportError(Diagnostics.Types_of_parameters_0_and_1_are_incompatible,
@@ -5615,7 +5624,7 @@ namespace ts {
                     let related: Ternary;
                     if (sourceStringType && sourceNumberType) {
                         // If we know for sure we're testing both string and numeric index types then only report errors from the second one
-                        related = isRelatedTo(sourceStringType, targetType, false) || isRelatedTo(sourceNumberType, targetType, reportErrors);
+                        related = isRelatedTo(sourceStringType, targetType, /*reportErrors*/ false) || isRelatedTo(sourceNumberType, targetType, reportErrors);
                     }
                     else {
                         related = isRelatedTo(sourceStringType || sourceNumberType, targetType, reportErrors);
@@ -6285,27 +6294,6 @@ namespace ts {
             Debug.fail("should not get here");
         }
 
-        // For a union type, remove all constituent types that are of the given type kind (when isOfTypeKind is true)
-        // or not of the given type kind (when isOfTypeKind is false)
-        function removeTypesFromUnionType(type: Type, typeKind: TypeFlags, isOfTypeKind: boolean, allowEmptyUnionResult: boolean): Type {
-            if (type.flags & TypeFlags.Union) {
-                const types = (<UnionType>type).types;
-                if (forEach(types, t => !!(t.flags & typeKind) === isOfTypeKind)) {
-                    // Above we checked if we have anything to remove, now use the opposite test to do the removal
-                    const narrowedType = getUnionType(filter(types, t => !(t.flags & typeKind) === isOfTypeKind));
-                    if (allowEmptyUnionResult || narrowedType !== emptyObjectType) {
-                        return narrowedType;
-                    }
-                }
-            }
-            else if (allowEmptyUnionResult && !!(type.flags & typeKind) === isOfTypeKind) {
-                // Use getUnionType(emptyArray) instead of emptyObjectType in case the way empty union types
-                // are represented ever changes.
-                return getUnionType(emptyArray);
-            }
-            return type;
-        }
-
         function hasInitializer(node: VariableLikeDeclaration): boolean {
             return !!(node.initializer || isBindingPattern(node.parent) && hasInitializer(<VariableLikeDeclaration>node.parent.parent));
         }
@@ -6407,33 +6395,16 @@ namespace ts {
             // Only narrow when symbol is variable of type any or an object, union, or type parameter type
             if (node && symbol.flags & SymbolFlags.Variable) {
                 if (isTypeAny(type) || type.flags & (TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) {
+                    const originalType = type;
+                    const nodeStack: {node: Node, child: Node}[] = [];
                     loop: while (node.parent) {
                         const child = node;
                         node = node.parent;
-                        let narrowedType = type;
                         switch (node.kind) {
                             case SyntaxKind.IfStatement:
-                                // In a branch of an if statement, narrow based on controlling expression
-                                if (child !== (<IfStatement>node).expression) {
-                                    narrowedType = narrowType(type, (<IfStatement>node).expression, /*assumeTrue*/ child === (<IfStatement>node).thenStatement);
-                                }
-                                break;
                             case SyntaxKind.ConditionalExpression:
-                                // In a branch of a conditional expression, narrow based on controlling condition
-                                if (child !== (<ConditionalExpression>node).condition) {
-                                    narrowedType = narrowType(type, (<ConditionalExpression>node).condition, /*assumeTrue*/ child === (<ConditionalExpression>node).whenTrue);
-                                }
-                                break;
                             case SyntaxKind.BinaryExpression:
-                                // In the right operand of an && or ||, narrow based on left operand
-                                if (child === (<BinaryExpression>node).right) {
-                                    if ((<BinaryExpression>node).operatorToken.kind === SyntaxKind.AmpersandAmpersandToken) {
-                                        narrowedType = narrowType(type, (<BinaryExpression>node).left, /*assumeTrue*/ true);
-                                    }
-                                    else if ((<BinaryExpression>node).operatorToken.kind === SyntaxKind.BarBarToken) {
-                                        narrowedType = narrowType(type, (<BinaryExpression>node).left, /*assumeTrue*/ false);
-                                    }
-                                }
+                                nodeStack.push({node, child});
                                 break;
                             case SyntaxKind.SourceFile:
                             case SyntaxKind.ModuleDeclaration:
@@ -6446,13 +6417,48 @@ namespace ts {
                                 // Stop at the first containing function or module declaration
                                 break loop;
                         }
-                        // Use narrowed type if construct contains no assignments to variable
-                        if (narrowedType !== type) {
-                            if (isVariableAssignedWithin(symbol, node)) {
+                    }
+
+                    let nodes: {node: Node, child: Node};
+                    while (nodes = nodeStack.pop()) {
+                        const {node, child} = nodes;
+                        switch (node.kind) {
+                            case SyntaxKind.IfStatement:
+                                // In a branch of an if statement, narrow based on controlling expression
+                                if (child !== (<IfStatement>node).expression) {
+                                    type = narrowType(type, (<IfStatement>node).expression, /*assumeTrue*/ child === (<IfStatement>node).thenStatement);
+                                }
                                 break;
-                            }
-                            type = narrowedType;
+                            case SyntaxKind.ConditionalExpression:
+                                // In a branch of a conditional expression, narrow based on controlling condition
+                                if (child !== (<ConditionalExpression>node).condition) {
+                                    type = narrowType(type, (<ConditionalExpression>node).condition, /*assumeTrue*/ child === (<ConditionalExpression>node).whenTrue);
+                                }
+                                break;
+                            case SyntaxKind.BinaryExpression:
+                                // In the right operand of an && or ||, narrow based on left operand
+                                if (child === (<BinaryExpression>node).right) {
+                                    if ((<BinaryExpression>node).operatorToken.kind === SyntaxKind.AmpersandAmpersandToken) {
+                                        type = narrowType(type, (<BinaryExpression>node).left, /*assumeTrue*/ true);
+                                    }
+                                    else if ((<BinaryExpression>node).operatorToken.kind === SyntaxKind.BarBarToken) {
+                                        type = narrowType(type, (<BinaryExpression>node).left, /*assumeTrue*/ false);
+                                    }
+                                }
+                                break;
+                            default:
+                                Debug.fail("Unreachable!");
                         }
+
+                        // Use original type if construct contains assignments to variable
+                        if (type !== originalType && isVariableAssignedWithin(symbol, node)) {
+                            type = originalType;
+                        }
+                    }
+
+                    // Preserve old top-level behavior - if the branch is really an empty set, revert to prior type
+                    if (type === emptyUnionType) {
+                        type = originalType;
                     }
                 }
             }
@@ -6469,31 +6475,35 @@ namespace ts {
                 if (left.expression.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>left.expression) !== symbol) {
                     return type;
                 }
-                const typeInfo = primitiveTypeInfo[right.text];
                 if (expr.operatorToken.kind === SyntaxKind.ExclamationEqualsEqualsToken) {
                     assumeTrue = !assumeTrue;
                 }
-                if (assumeTrue) {
-                    // Assumed result is true. If check was not for a primitive type, remove all primitive types
-                    if (!typeInfo) {
-                        return removeTypesFromUnionType(type, /*typeKind*/ TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.Boolean | TypeFlags.ESSymbol,
-                            /*isOfTypeKind*/ true, /*allowEmptyUnionResult*/ false);
-                    }
-                    // Check was for a primitive type, return that primitive type if it is a subtype
-                    if (isTypeSubtypeOf(typeInfo.type, type)) {
-                        return typeInfo.type;
-                    }
-                    // Otherwise, remove all types that aren't of the primitive type kind. This can happen when the type is
-                    // union of enum types and other types.
-                    return removeTypesFromUnionType(type, /*typeKind*/ typeInfo.flags, /*isOfTypeKind*/ false, /*allowEmptyUnionResult*/ false);
+                const typeInfo = primitiveTypeInfo[right.text];
+                // Don't narrow `undefined`
+                if (typeInfo && typeInfo.type === undefinedType) {
+                    return type;
+                }
+                // If the type to be narrowed is any and we're checking a primitive with assumeTrue=true, return the primitive
+                if (!!(type.flags & TypeFlags.Any) && typeInfo && assumeTrue) {
+                    return typeInfo.type;
+                }
+                let flags: TypeFlags;
+                if (typeInfo) {
+                    flags = typeInfo.flags;
                 }
                 else {
-                    // Assumed result is false. If check was for a primitive type, remove that primitive type
-                    if (typeInfo) {
-                        return removeTypesFromUnionType(type, /*typeKind*/ typeInfo.flags, /*isOfTypeKind*/ true, /*allowEmptyUnionResult*/ false);
-                    }
-                    // Otherwise we don't have enough information to do anything.
-                    return type;
+                    assumeTrue = !assumeTrue;
+                    flags = TypeFlags.NumberLike | TypeFlags.StringLike | TypeFlags.ESSymbol | TypeFlags.Boolean;
+                }
+                // At this point we can bail if it's not a union
+                if (!(type.flags & TypeFlags.Union)) {
+                    // If the active non-union type would be removed from a union by this type guard, return an empty union
+                    return filterUnion(type) ? type : emptyUnionType;
+                }
+                return getUnionType(filter((type as UnionType).types, filterUnion), /*noSubtypeReduction*/ true);
+
+                function filterUnion(type: Type) {
+                    return assumeTrue === !!(type.flags & flags);
                 }
             }
 
@@ -6507,7 +6517,7 @@ namespace ts {
                     // and the second operand was false. We narrow with those assumptions and union the two resulting types.
                     return getUnionType([
                         narrowType(type, expr.left, /*assumeTrue*/ false),
-                        narrowType(narrowType(type, expr.left, /*assumeTrue*/ true), expr.right, /*assumeTrue*/ false)
+                        narrowType(type, expr.right, /*assumeTrue*/ false)
                     ]);
                 }
             }
@@ -6518,7 +6528,7 @@ namespace ts {
                     // and the second operand was true. We narrow with those assumptions and union the two resulting types.
                     return getUnionType([
                         narrowType(type, expr.left, /*assumeTrue*/ true),
-                        narrowType(narrowType(type, expr.left, /*assumeTrue*/ false), expr.right, /*assumeTrue*/ true)
+                        narrowType(type, expr.right, /*assumeTrue*/ true)
                     ]);
                 }
                 else {
@@ -11350,11 +11360,15 @@ namespace ts {
                         const errorNode: Node = (<FunctionLikeDeclaration>subsequentNode).name || subsequentNode;
                         // TODO(jfreeman): These are methods, so handle computed name case
                         if (node.name && (<FunctionLikeDeclaration>subsequentNode).name && (<Identifier>node.name).text === (<Identifier>(<FunctionLikeDeclaration>subsequentNode).name).text) {
-                            // the only situation when this is possible (same kind\same name but different symbol) - mixed static and instance class members
                             Debug.assert(node.kind === SyntaxKind.MethodDeclaration || node.kind === SyntaxKind.MethodSignature);
-                            Debug.assert((node.flags & NodeFlags.Static) !== (subsequentNode.flags & NodeFlags.Static));
-                            const diagnostic = node.flags & NodeFlags.Static ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static;
-                            error(errorNode, diagnostic);
+                            // we can get here in two cases
+                            // 1. mixed static and instance class members
+                            // 2. something with the same name was defined before the set of overloads that prevents them from merging
+                            // here we'll report error only for the first case since for second we should already report error in binder 
+                            if ((node.flags & NodeFlags.Static) !== (subsequentNode.flags & NodeFlags.Static)) {
+                                const diagnostic = node.flags & NodeFlags.Static ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static;
+                                error(errorNode, diagnostic);
+                            }
                             return;
                         }
                         else if (nodeIsPresent((<FunctionLikeDeclaration>subsequentNode).body)) {
@@ -12736,9 +12750,14 @@ namespace ts {
 
             // After we remove all types that are StringLike, we will know if there was a string constituent
             // based on whether the remaining type is the same as the initial type.
-            const arrayType = removeTypesFromUnionType(arrayOrStringType, TypeFlags.StringLike, /*isTypeOfKind*/ true, /*allowEmptyUnionResult*/ true);
+            let arrayType = arrayOrStringType;
+            if (arrayOrStringType.flags & TypeFlags.Union) {
+                arrayType = getUnionType(filter((arrayOrStringType as UnionType).types, t => !(t.flags & TypeFlags.StringLike)));
+            }
+            else if (arrayOrStringType.flags & TypeFlags.StringLike) {
+                arrayType = emptyUnionType;
+            }
             const hasStringConstituent = arrayOrStringType !== arrayType;
-
             let reportedError = false;
             if (hasStringConstituent) {
                 if (languageVersion < ScriptTarget.ES5) {
@@ -12884,13 +12903,13 @@ namespace ts {
                     // In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression.
                     const caseType = checkExpression(caseClause.expression);
 
-                    // Permit 'number[] | "foo"' to be asserted to 'string'.
-                    if (expressionTypeIsStringLike && someConstituentTypeHasKind(caseType, TypeFlags.StringLike)) {
-                        return;
-                    }
+                    const expressionTypeIsAssignableToCaseType =
+                        // Permit 'number[] | "foo"' to be asserted to 'string'.
+                        (expressionTypeIsStringLike && someConstituentTypeHasKind(caseType, TypeFlags.StringLike)) ||
+                        isTypeAssignableTo(expressionType, caseType);
 
-                    if (!isTypeAssignableTo(expressionType, caseType)) {
-                        // check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails
+                    if (!expressionTypeIsAssignableToCaseType) {
+                        // 'expressionType is not assignable to caseType', try the reversed check and report errors if it fails
                         checkTypeAssignableTo(caseType, expressionType, caseClause.expression, /*headMessage*/ undefined);
                     }
                 }

src/compiler/core.ts

@@ -842,7 +842,7 @@ namespace ts {
         }
 
         export function fail(message?: string): void {
-            Debug.assert(false, message);
+            Debug.assert(/*expression*/ false, message);
         }
     }
 

src/compiler/emitter.ts

@@ -1292,7 +1292,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
             function emitCommaList(nodes: Node[]) {
                 if (nodes) {
-                    emitList(nodes, 0, nodes.length, /*multiline*/ false, /*trailingComma*/ false);
+                    emitList(nodes, 0, nodes.length, /*multiLine*/ false, /*trailingComma*/ false);
                 }
             }
 
@@ -1592,13 +1592,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 /// these emit into an object literal property name, we don't need to be worried
                 /// about keywords, just non-identifier characters
                 function emitAttributeName(name: Identifier) {
-                    if (/[A-Za-z_]+[\w*]/.test(name.text)) {
-                        write("\"");
+                    if (/^[A-Za-z_]\w*$/.test(name.text)) {
                         emit(name);
-                        write("\"");
                     }
                     else {
+                        write("\"");
                         emit(name);
+                        write("\"");
                     }
                 }
 
@@ -2191,7 +2191,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 else if (languageVersion >= ScriptTarget.ES6 || !forEach(elements, isSpreadElementExpression)) {
                     write("[");
-                    emitLinePreservingList(node, node.elements, elements.hasTrailingComma, /*spacesBetweenBraces:*/ false);
+                    emitLinePreservingList(node, node.elements, elements.hasTrailingComma, /*spacesBetweenBraces*/ false);
                     write("]");
                 }
                 else {
@@ -2215,7 +2215,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     // then try to preserve the original shape of the object literal.
                     // Otherwise just try to preserve the formatting.
                     if (numElements === properties.length) {
-                        emitLinePreservingList(node, properties, /* allowTrailingComma */ languageVersion >= ScriptTarget.ES5, /* spacesBetweenBraces */ true);
+                        emitLinePreservingList(node, properties, /*allowTrailingComma*/ languageVersion >= ScriptTarget.ES5, /*spacesBetweenBraces*/ true);
                     }
                     else {
                         const multiLine = (node.flags & NodeFlags.MultiLine) !== 0;
@@ -2765,7 +2765,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(".bind.apply(");
                     emit(target);
                     write(", [void 0].concat(");
-                    emitListWithSpread(node.arguments, /*needsUniqueCopy*/ false, /*multiline*/ false, /*trailingComma*/ false, /*useConcat*/ false);
+                    emitListWithSpread(node.arguments, /*needsUniqueCopy*/ false, /*multiLine*/ false, /*trailingComma*/ false, /*useConcat*/ false);
                     write(")))");
                     write("()");
                 }
@@ -2982,7 +2982,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                         synthesizedLHS = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression, /*startsOnNewLine*/ false);
 
-                        const identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
+                        const identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefineTempVariablesInPlace*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
                         synthesizedLHS.expression = identifier;
 
                         if (leftHandSideExpression.argumentExpression.kind !== SyntaxKind.NumericLiteral &&
@@ -3001,7 +3001,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         write("(");
                         synthesizedLHS = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression, /*startsOnNewLine*/ false);
 
-                        const identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefinedTempVariablesInPlaces*/ false, /*shouldemitCommaBeforeAssignment*/ false);
+                        const identifier = emitTempVariableAssignment(leftHandSideExpression.expression, /*canDefineTempVariablesInPlace*/ false, /*shouldEmitCommaBeforeAssignment*/ false);
                         synthesizedLHS.expression = identifier;
 
                         (<PropertyAccessExpression>synthesizedLHS).dotToken = leftHandSideExpression.dotToken;
@@ -3181,10 +3181,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             function emitDoStatementWorker(node: DoStatement, loop: ConvertedLoop) {
                 write("do");
                 if (loop) {
-                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
                 }
                 else {
-                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
                 }
                 if (node.statement.kind === SyntaxKind.Block) {
                     write(" ");
@@ -3207,10 +3207,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(")");
 
                 if (loop) {
-                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
                 }
                 else {
-                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
                 }
             }
 
@@ -3532,8 +3532,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(`switch(${loopResultVariable}) {`);
                     increaseIndent();
 
-                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalBreaks, /* isBreak */ true, loopResultVariable, outerLoop);
-                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalContinues, /* isBreak */ false, loopResultVariable, outerLoop);
+                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalBreaks, /*isBreak*/ true, loopResultVariable, outerLoop);
+                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalContinues, /*isBreak*/ false, loopResultVariable, outerLoop);
 
                     decreaseIndent();
                     writeLine();
@@ -3597,10 +3597,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(")");
 
                 if (loop) {
-                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
                 }
                 else {
-                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
                 }
             }
 
@@ -3638,10 +3638,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitToken(SyntaxKind.CloseParenToken, node.expression.end);
 
                 if (loop) {
-                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ true);
                 }
                 else {
-                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ true);
                 }
             }
 
@@ -3781,10 +3781,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
 
                 if (loop) {
                     writeLine();
-                    emitConvertedLoopCall(loop, /* emitAsBlock */ false);
+                    emitConvertedLoopCall(loop, /*emitAsBlock*/ false);
                 }
                 else {
-                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ false);
+                    emitNormalLoopBody(node, /*emitAsEmbeddedStatement*/ false);
                 }
 
                 writeLine();
@@ -3818,11 +3818,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             let labelMarker: string;
                             if (node.kind === SyntaxKind.BreakStatement) {
                                 labelMarker = `break-${node.label.text}`;
-                                setLabeledJump(convertedLoopState, /* isBreak */ true, node.label.text, labelMarker);
+                                setLabeledJump(convertedLoopState, /*isBreak*/ true, node.label.text, labelMarker);
                             }
                             else {
                                 labelMarker = `continue-${node.label.text}`;
-                                setLabeledJump(convertedLoopState, /* isBreak */ false, node.label.text, labelMarker);
+                                setLabeledJump(convertedLoopState, /*isBreak*/ false, node.label.text, labelMarker);
                             }
                             write(`return "${labelMarker}";`);
                         }
@@ -4248,7 +4248,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     let index: Expression;
                     const nameIsComputed = propName.kind === SyntaxKind.ComputedPropertyName;
                     if (nameIsComputed) {
-                        index = ensureIdentifier((<ComputedPropertyName>propName).expression, /* reuseIdentifierExpression */ false);
+                        index = ensureIdentifier((<ComputedPropertyName>propName).expression, /*reuseIdentifierExpressions*/ false);
                     }
                     else {
                         // We create a synthetic copy of the identifier in order to avoid the rewriting that might
@@ -5003,8 +5003,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     increaseIndent();
                     writeLine();
                     emitLeadingComments(node.body);
+                    emitStart(body);
                     write("return ");
                     emit(body);
+                    emitEnd(body);
                     write(";");
                     emitTrailingComments(node.body);
 
@@ -5378,7 +5380,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         emitEnd(baseTypeElement);
                     }
                 }
-                emitPropertyDeclarations(node, getInitializedProperties(node, /*static:*/ false));
+                emitPropertyDeclarations(node, getInitializedProperties(node, /*isStatic*/ false));
                 if (ctor) {
                     let statements: Node[] = (<Block>ctor.body).statements;
                     if (superCall) {
@@ -5500,7 +5502,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 //
                 // This keeps the expression as an expression, while ensuring that the static parts
                 // of it have been initialized by the time it is used.
-                const staticProperties = getInitializedProperties(node, /*static:*/ true);
+                const staticProperties = getInitializedProperties(node, /*isStatic*/ true);
                 const isClassExpressionWithStaticProperties = staticProperties.length > 0 && node.kind === SyntaxKind.ClassExpression;
                 let tempVariable: Identifier;
 
@@ -5562,7 +5564,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     for (var property of staticProperties) {
                         write(",");
                         writeLine();
-                        emitPropertyDeclaration(node, property, /*receiver:*/ tempVariable, /*isExpression:*/ true);
+                        emitPropertyDeclaration(node, property, /*receiver*/ tempVariable, /*isExpression*/ true);
                     }
                     write(",");
                     writeLine();
@@ -5636,7 +5638,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 writeLine();
                 emitConstructor(node, baseTypeNode);
                 emitMemberFunctionsForES5AndLower(node);
-                emitPropertyDeclarations(node, getInitializedProperties(node, /*static:*/ true));
+                emitPropertyDeclarations(node, getInitializedProperties(node, /*isStatic*/ true));
                 writeLine();
                 emitDecoratorsOfClass(node);
                 writeLine();
@@ -8092,11 +8094,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
              * Emit comments associated with node that will not be emitted into JS file
              */
             function emitCommentsOnNotEmittedNode(node: Node) {
-                emitLeadingCommentsWorker(node, /*isEmittedNode:*/ false);
+                emitLeadingCommentsWorker(node, /*isEmittedNode*/ false);
             }
 
             function emitLeadingComments(node: Node) {
-                return emitLeadingCommentsWorker(node, /*isEmittedNode:*/ true);
+                return emitLeadingCommentsWorker(node, /*isEmittedNode*/ true);
             }
 
             function emitLeadingCommentsWorker(node: Node, isEmittedNode: boolean) {
@@ -8125,7 +8127,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitNewLineBeforeLeadingComments(currentLineMap, writer, node, leadingComments);
 
                 // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space
-                emitComments(currentText, currentLineMap, writer, leadingComments, /*trailingSeparator:*/ true, newLine, writeComment);
+                emitComments(currentText, currentLineMap, writer, leadingComments, /*trailingSeparator*/ true, newLine, writeComment);
             }
 
             function emitTrailingComments(node: Node) {

src/compiler/parser.ts

@@ -722,10 +722,10 @@ namespace ts {
             const contextFlagsToClear = context & contextFlags;
             if (contextFlagsToClear) {
                 // clear the requested context flags
-                setContextFlag(false, contextFlagsToClear);
+                setContextFlag(/*val*/ false, contextFlagsToClear);
                 const result = func();
                 // restore the context flags we just cleared
-                setContextFlag(true, contextFlagsToClear);
+                setContextFlag(/*val*/ true, contextFlagsToClear);
                 return result;
             }
 
@@ -743,10 +743,10 @@ namespace ts {
             const contextFlagsToSet = context & ~contextFlags;
             if (contextFlagsToSet) {
                 // set the requested context flags
-                setContextFlag(true, contextFlagsToSet);
+                setContextFlag(/*val*/ true, contextFlagsToSet);
                 const result = func();
                 // reset the context flags we just set
-                setContextFlag(false, contextFlagsToSet);
+                setContextFlag(/*val*/ false, contextFlagsToSet);
                 return result;
             }
 
@@ -1098,11 +1098,11 @@ namespace ts {
         }
 
         function parsePropertyName(): PropertyName {
-            return parsePropertyNameWorker(/*allowComputedPropertyNames:*/ true);
+            return parsePropertyNameWorker(/*allowComputedPropertyNames*/ true);
         }
 
         function parseSimplePropertyName(): Identifier | LiteralExpression {
-            return <Identifier | LiteralExpression>parsePropertyNameWorker(/*allowComputedPropertyNames:*/ false);
+            return <Identifier | LiteralExpression>parsePropertyNameWorker(/*allowComputedPropertyNames*/ false);
         }
 
         function isSimplePropertyName() {
@@ -1385,7 +1385,7 @@ namespace ts {
         function isInSomeParsingContext(): boolean {
             for (let kind = 0; kind < ParsingContext.Count; kind++) {
                 if (parsingContext & (1 << kind)) {
-                    if (isListElement(kind, /* inErrorRecovery */ true) || isListTerminator(kind)) {
+                    if (isListElement(kind, /*inErrorRecovery*/ true) || isListTerminator(kind)) {
                         return true;
                     }
                 }
@@ -1402,7 +1402,7 @@ namespace ts {
             result.pos = getNodePos();
 
             while (!isListTerminator(kind)) {
-                if (isListElement(kind, /* inErrorRecovery */ false)) {
+                if (isListElement(kind, /*inErrorRecovery*/ false)) {
                     const element = parseListElement(kind, parseElement);
                     result.push(element);
 
@@ -1751,7 +1751,7 @@ namespace ts {
 
             let commaStart = -1; // Meaning the previous token was not a comma
             while (true) {
-                if (isListElement(kind, /* inErrorRecovery */ false)) {
+                if (isListElement(kind, /*inErrorRecovery*/ false)) {
                     result.push(parseListElement(kind, parseElement));
                     commaStart = scanner.getTokenPos();
                     if (parseOptional(SyntaxKind.CommaToken)) {
@@ -1859,7 +1859,7 @@ namespace ts {
                     // Report that we need an identifier.  However, report it right after the dot,
                     // and not on the next token.  This is because the next token might actually
                     // be an identifier and the error would be quite confusing.
-                    return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentToken*/ true, Diagnostics.Identifier_expected);
+                    return <Identifier>createMissingNode(SyntaxKind.Identifier, /*reportAtCurrentPosition*/ true, Diagnostics.Identifier_expected);
                 }
             }
 
@@ -2609,7 +2609,7 @@ namespace ts {
             // clear the decorator context when parsing Expression, as it should be unambiguous when parsing a decorator
             const saveDecoratorContext = inDecoratorContext();
             if (saveDecoratorContext) {
-                setDecoratorContext(false);
+                setDecoratorContext(/*val*/ false);
             }
 
             let expr = parseAssignmentExpressionOrHigher();
@@ -2619,7 +2619,7 @@ namespace ts {
             }
 
             if (saveDecoratorContext) {
-                setDecoratorContext(true);
+                setDecoratorContext(/*val*/ true);
             }
             return expr;
         }
@@ -2773,7 +2773,7 @@ namespace ts {
             node.parameters.pos = parameter.pos;
             node.parameters.end = parameter.end;
 
-            node.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, false, Diagnostics._0_expected, "=>");
+            node.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition*/ false, Diagnostics._0_expected, "=>");
             node.body = parseArrowFunctionExpressionBody(/*isAsync*/ false);
 
             return finishNode(node);
@@ -3573,7 +3573,7 @@ namespace ts {
                     parseExpected(SyntaxKind.GreaterThanToken);
                 }
                 else {
-                    parseExpected(SyntaxKind.GreaterThanToken, /*diagnostic*/ undefined, /*advance*/ false);
+                    parseExpected(SyntaxKind.GreaterThanToken, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
                     scanJsxText();
                 }
                 node = <JsxSelfClosingElement>createNode(SyntaxKind.JsxSelfClosingElement, fullStart);
@@ -3609,7 +3609,7 @@ namespace ts {
                 parseExpected(SyntaxKind.CloseBraceToken);
             }
             else {
-                parseExpected(SyntaxKind.CloseBraceToken, /*message*/ undefined, /*advance*/ false);
+                parseExpected(SyntaxKind.CloseBraceToken, /*message*/ undefined, /*shouldAdvance*/ false);
                 scanJsxText();
             }
 
@@ -3654,7 +3654,7 @@ namespace ts {
                 parseExpected(SyntaxKind.GreaterThanToken);
             }
             else {
-                parseExpected(SyntaxKind.GreaterThanToken, /*diagnostic*/ undefined, /*advance*/ false);
+                parseExpected(SyntaxKind.GreaterThanToken, /*diagnostic*/ undefined, /*shouldAdvance*/ false);
                 scanJsxText();
             }
             return finishNode(node);
@@ -3973,7 +3973,7 @@ namespace ts {
             //      function BindingIdentifier[opt](FormalParameters){ FunctionBody }
             const saveDecoratorContext = inDecoratorContext();
             if (saveDecoratorContext) {
-                setDecoratorContext(false);
+                setDecoratorContext(/*val*/ false);
             }
 
             const node = <FunctionExpression>createNode(SyntaxKind.FunctionExpression);
@@ -3993,7 +3993,7 @@ namespace ts {
             node.body = parseFunctionBlock(/*allowYield*/ isGenerator, /*allowAwait*/ isAsync, /*ignoreMissingOpenBrace*/ false);
 
             if (saveDecoratorContext) {
-                setDecoratorContext(true);
+                setDecoratorContext(/*val*/ true);
             }
 
             return finishNode(node);
@@ -4039,13 +4039,13 @@ namespace ts {
             // arrow function. The body of the function is not in [Decorator] context.
             const saveDecoratorContext = inDecoratorContext();
             if (saveDecoratorContext) {
-                setDecoratorContext(false);
+                setDecoratorContext(/*val*/ false);
             }
 
             const block = parseBlock(ignoreMissingOpenBrace, diagnosticMessage);
 
             if (saveDecoratorContext) {
-                setDecoratorContext(true);
+                setDecoratorContext(/*val*/ true);
             }
 
             setYieldContext(savedYieldContext);
@@ -6162,7 +6162,7 @@ namespace ts {
             if (sourceFile.statements.length === 0) {
                 // If we don't have any statements in the current source file, then there's no real
                 // way to incrementally parse.  So just do a full parse instead.
-                return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, /*syntaxCursor*/ undefined, /*setNodeParents*/ true);
+                return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, /*syntaxCursor*/ undefined, /*setParentNodes*/ true);
             }
 
             // Make sure we're not trying to incrementally update a source file more than once.  Once
@@ -6226,7 +6226,7 @@ namespace ts {
             // inconsistent tree.  Setting the parents on the new tree should be very fast.  We
             // will immediately bail out of walking any subtrees when we can see that their parents
             // are already correct.
-            const result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /* setParentNode */ true);
+            const result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /*setParentNodes*/ true);
 
             return result;
         }

src/compiler/program.ts

@@ -364,13 +364,13 @@ namespace ts {
         }
 
         if (!tryReuseStructureFromOldProgram()) {
-            forEach(rootNames, name => processRootFile(name, false));
+            forEach(rootNames, name => processRootFile(name, /*isDefaultLib*/ false));
             // Do not process the default library if:
             //  - The '--noLib' flag is used.
             //  - A 'no-default-lib' reference comment is encountered in
             //      processing the root files.
             if (!skipDefaultLib) {
-                processRootFile(host.getDefaultLibFileName(options), true);
+                processRootFile(host.getDefaultLibFileName(options), /*isDefaultLib*/ true);
             }
         }
 
@@ -693,7 +693,7 @@ namespace ts {
 
             let imports: LiteralExpression[];
             for (const node of file.statements) {
-                collect(node, /* allowRelativeModuleNames */ true, /* collectOnlyRequireCalls */ false);
+                collect(node, /*allowRelativeModuleNames*/ true, /*collectOnlyRequireCalls*/ false);
             }
 
             file.imports = imports || emptyArray;
@@ -729,7 +729,7 @@ namespace ts {
                                     // TypeScript 1.0 spec (April 2014): 12.1.6
                                     // An ExternalImportDeclaration in anAmbientExternalModuleDeclaration may reference other external modules 
                                     // only through top - level external module names. Relative external module names are not permitted.
-                                    collect(node, /* allowRelativeModuleNames */ false, collectOnlyRequireCalls);
+                                    collect(node, /*allowRelativeModuleNames*/ false, collectOnlyRequireCalls);
                                 });
                             }
                             break;
@@ -741,7 +741,7 @@ namespace ts {
                         (imports || (imports = [])).push(<StringLiteral>(<CallExpression>node).arguments[0]);
                     }
                     else {
-                        forEachChild(node, node => collect(node, allowRelativeModuleNames, /* collectOnlyRequireCalls */ true));
+                        forEachChild(node, node => collect(node, allowRelativeModuleNames, /*collectOnlyRequireCalls*/ true));
                     }
                 }
             }
@@ -862,7 +862,7 @@ namespace ts {
         function processReferencedFiles(file: SourceFile, basePath: string) {
             forEach(file.referencedFiles, ref => {
                 const referencedFileName = resolveTripleslashReference(ref.fileName, file.fileName);
-                processSourceFile(referencedFileName, /* isDefaultLib */ false, file, ref.pos, ref.end);
+                processSourceFile(referencedFileName, /*isDefaultLib*/ false, file, ref.pos, ref.end);
             });
         }
 
@@ -880,7 +880,7 @@ namespace ts {
                     const resolution = resolutions[i];
                     setResolvedModule(file, moduleNames[i], resolution);
                     if (resolution && !options.noResolve) {
-                        const importedFile = findSourceFile(resolution.resolvedFileName, toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), /* isDefaultLib */ false, file, skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
+                        const importedFile = findSourceFile(resolution.resolvedFileName, toPath(resolution.resolvedFileName, currentDirectory, getCanonicalFileName), /*isDefaultLib*/ false, file, skipTrivia(file.text, file.imports[i].pos), file.imports[i].end);
 
                         if (importedFile && resolution.isExternalLibraryImport) {
                             if (!isExternalModule(importedFile)) {
@@ -990,16 +990,15 @@ namespace ts {
                 if (options.mapRoot) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap"));
                 }
-                if (options.sourceRoot) {
-                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceRoot", "inlineSourceMap"));
-                }
             }
 
-
             if (options.inlineSources) {
                 if (!options.sourceMap && !options.inlineSourceMap) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_inlineSources_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided));
                 }
+                if (options.sourceRoot) {
+                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceRoot", "inlineSources"));
+                }
             }
 
             if (options.out && options.outFile) {
@@ -1011,10 +1010,9 @@ namespace ts {
                 if (options.mapRoot) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "mapRoot", "sourceMap"));
                 }
-                if (options.sourceRoot) {
+                if (options.sourceRoot && !options.inlineSourceMap) {
                     programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "sourceRoot", "sourceMap"));
                 }
-                return;
             }
 
             const languageVersion = options.target || ScriptTarget.ES3;

src/compiler/scanner.ts

@@ -1634,11 +1634,11 @@ namespace ts {
         }
 
         function lookAhead<T>(callback: () => T): T {
-            return speculationHelper(callback, /*isLookahead:*/ true);
+            return speculationHelper(callback, /*isLookahead*/ true);
         }
 
         function tryScan<T>(callback: () => T): T {
-            return speculationHelper(callback, /*isLookahead:*/ false);
+            return speculationHelper(callback, /*isLookahead*/ false);
         }
 
         function setText(newText: string, start: number, length: number) {

src/harness/compilerRunner.ts

@@ -49,7 +49,7 @@ class CompilerBaselineRunner extends RunnerBase {
             let testCaseContent: { settings: Harness.TestCaseParser.CompilerSettings; testUnitData: Harness.TestCaseParser.TestUnitData[]; };
 
             let units: Harness.TestCaseParser.TestUnitData[];
-            let tcSettings: Harness.TestCaseParser.CompilerSettings;
+            let harnessSettings: Harness.TestCaseParser.CompilerSettings;
 
             let lastUnit: Harness.TestCaseParser.TestUnitData;
             let rootDir: string;
@@ -58,46 +58,43 @@ class CompilerBaselineRunner extends RunnerBase {
             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 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;
+                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();
                 // 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: ts.combinePaths(rootDir, lastUnit.name), content: lastUnit.content });
                     units.forEach(unit => {
                         if (unit.name !== lastUnit.name) {
-                            otherFiles.push({ unitName: rootDir + unit.name, content: unit.content });
+                            otherFiles.push({ unitName: ts.combinePaths(rootDir, unit.name), content: unit.content });
                         }
                     });
                 }
                 else {
                     toBeCompiled = units.map(unit => {
-                        return { unitName: rootDir + unit.name, content: unit.content };
+                        return { unitName: ts.combinePaths(rootDir, unit.name), 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.HarnessCompiler.compileFiles(
+                    toBeCompiled, otherFiles, harnessSettings, /* options */ undefined, /* currentDirectory */ undefined);
+
+                options = output.options;
+                result = output.result;
+                program = output.program;
             });
 
             after(() => {
@@ -107,7 +104,7 @@ class CompilerBaselineRunner extends RunnerBase {
                 content = undefined;
                 testCaseContent = undefined;
                 units = undefined;
-                tcSettings = undefined;
+                harnessSettings = undefined;
                 lastUnit = undefined;
                 rootDir = undefined;
                 result = undefined;
@@ -115,14 +112,13 @@ class CompilerBaselineRunner extends RunnerBase {
                 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);
             }
 
@@ -184,9 +180,9 @@ class CompilerBaselineRunner extends RunnerBase {
                             }
                         }
 
-                        const declFileCompilationResult = harnessCompiler.compileDeclarationFiles(toBeCompiled, otherFiles, result, function (settings) {
-                            harnessCompiler.setCompilerSettings(tcSettings);
-                        }, options);
+                        const declFileCompilationResult =
+                            Harness.Compiler.HarnessCompiler.compileDeclarationFiles(
+                                toBeCompiled, otherFiles, result, harnessSettings, options, /*currentDirectory*/ undefined);
 
                         if (declFileCompilationResult && declFileCompilationResult.declResult.errors.length) {
                             jsCode += "\r\n\r\n//// [DtsFileErrors]\r\n";
@@ -259,8 +255,8 @@ class CompilerBaselineRunner extends RunnerBase {
 
                     const allFiles = toBeCompiled.concat(otherFiles).filter(file => !!program.getSourceFile(file.unitName));
 
-                    const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ true);
-                    const pullWalker = new TypeWriterWalker(program, /*fullTypeCheck:*/ false);
+                    const fullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ true);
+                    const pullWalker = new TypeWriterWalker(program, /*fullTypeCheck*/ false);
 
                     const fullResults: ts.Map<TypeWriterResult[]> = {};
                     const pullResults: ts.Map<TypeWriterResult[]> = {};
@@ -274,14 +270,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;
@@ -367,7 +363,6 @@ class CompilerBaselineRunner extends RunnerBase {
     public initializeTests() {
         describe(this.testSuiteName + " tests", () => {
             describe("Setup compiler for compiler baselines", () => {
-                const harnessCompiler = Harness.Compiler.getCompiler();
                 this.parseOptions();
             });
 

src/harness/fourslash.ts

@@ -385,9 +385,9 @@ namespace FourSlash {
         }
 
         // Opens a file given its 0-based index or fileName
-        public openFile(index: number): void;
-        public openFile(name: string): void;
-        public openFile(indexOrName: any) {
+        public openFile(index: number, content?: string): void;
+        public openFile(name: string, content?: string): void;
+        public openFile(indexOrName: any, content?: string) {
             const fileToOpen: FourSlashFile = this.findFile(indexOrName);
             fileToOpen.fileName = ts.normalizeSlashes(fileToOpen.fileName);
             this.activeFile = fileToOpen;
@@ -395,7 +395,7 @@ namespace FourSlash {
             this.scenarioActions.push(`<OpenFile FileName="" SrcFileId="${fileName}" FileId="${fileName}" />`);
 
             // Let the host know that this file is now open
-            this.languageServiceAdapterHost.openFile(fileToOpen.fileName);
+            this.languageServiceAdapterHost.openFile(fileToOpen.fileName, content);
         }
 
         public verifyErrorExistsBetweenMarkers(startMarkerName: string, endMarkerName: string, negative: boolean) {
@@ -514,7 +514,7 @@ namespace FourSlash {
             this.scenarioActions.push(`<CheckErrorList ExpectedNumOfErrors="${expected}" />`);
 
             if (actual !== expected) {
-                this.printErrorLog(false, errors);
+                this.printErrorLog(/*expectErrors*/ false, errors);
                 const errorMsg = "Actual number of errors (" + actual + ") does not match expected number (" + expected + ")";
                 Harness.IO.log(errorMsg);
                 this.raiseError(errorMsg);
@@ -567,7 +567,7 @@ namespace FourSlash {
         public verifyMemberListCount(expectedCount: number, negative: boolean) {
             if (expectedCount === 0) {
                 if (negative) {
-                    this.verifyMemberListIsEmpty(false);
+                    this.verifyMemberListIsEmpty(/*negative*/ false);
                     return;
                 }
                 else {
@@ -1347,7 +1347,7 @@ namespace FourSlash {
                 if (this.enableFormatting) {
                     const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
-                        offset += this.applyEdits(this.activeFile.fileName, edits, true);
+                        offset += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
                         // this.checkPostEditInletiants();
                     }
                 }
@@ -1389,7 +1389,7 @@ namespace FourSlash {
                 if (this.enableFormatting) {
                     const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
-                        offset += this.applyEdits(this.activeFile.fileName, edits, true);
+                        offset += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
                     }
                 }
             }
@@ -1449,7 +1449,7 @@ namespace FourSlash {
                 if (this.enableFormatting) {
                     const edits = this.languageService.getFormattingEditsAfterKeystroke(this.activeFile.fileName, offset, ch, this.formatCodeOptions);
                     if (edits.length) {
-                        offset += this.applyEdits(this.activeFile.fileName, edits, true);
+                        offset += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
                         // this.checkPostEditInletiants();
                     }
                 }
@@ -1477,7 +1477,7 @@ namespace FourSlash {
             if (this.enableFormatting) {
                 const edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, offset, this.formatCodeOptions);
                 if (edits.length) {
-                    offset += this.applyEdits(this.activeFile.fileName, edits, true);
+                    offset += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
                     this.checkPostEditInletiants();
                 }
             }
@@ -1563,7 +1563,7 @@ namespace FourSlash {
             this.scenarioActions.push("<FormatDocument />");
 
             const edits = this.languageService.getFormattingEditsForDocument(this.activeFile.fileName, this.formatCodeOptions);
-            this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, true);
+            this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
             this.fixCaretPosition();
         }
 
@@ -1571,7 +1571,7 @@ namespace FourSlash {
             this.taoInvalidReason = "formatSelection NYI";
 
             const edits = this.languageService.getFormattingEditsForRange(this.activeFile.fileName, start, end, this.formatCodeOptions);
-            this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, true);
+            this.currentCaretPosition += this.applyEdits(this.activeFile.fileName, edits, /*isFormattingEdit*/ true);
             this.fixCaretPosition();
         }
 
@@ -2383,10 +2383,16 @@ namespace FourSlash {
     // here we cache the JS output and reuse it for every test.
     let fourslashJsOutput: string;
     {
-        const host = Harness.Compiler.createCompilerHost([{ unitName: Harness.Compiler.fourslashFileName, content: undefined }],
+        const fourslashFile: Harness.Compiler.TestFileWithPath = {
+            unitName: Harness.Compiler.fourslashFileName,
+            content: undefined,
+            path: ts.toPath(Harness.Compiler.fourslashFileName, Harness.IO.getCurrentDirectory(), Harness.Compiler.getCanonicalFileName)
+        };
+        const host = Harness.Compiler.createCompilerHost([fourslashFile],
             (fn, contents) => fourslashJsOutput = contents,
             ts.ScriptTarget.Latest,
-            Harness.IO.useCaseSensitiveFileNames());
+            Harness.IO.useCaseSensitiveFileNames(),
+            Harness.IO.getCurrentDirectory());
 
         const program = ts.createProgram([Harness.Compiler.fourslashFileName], { noResolve: true, target: ts.ScriptTarget.ES3 }, host);
 
@@ -2400,15 +2406,28 @@ namespace FourSlash {
 
         currentTestState = new TestState(basePath, testType, testData);
 
+        const currentDirectory = Harness.IO.getCurrentDirectory();
+        const useCaseSensitiveFileNames = Harness.IO.useCaseSensitiveFileNames();
+        const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
+
         let result = "";
+        const fourslashFile: Harness.Compiler.TestFileWithPath = {
+            unitName: Harness.Compiler.fourslashFileName,
+            content: undefined,
+            path: ts.toPath(Harness.Compiler.fourslashFileName, currentDirectory, getCanonicalFileName)
+        };
+        const testFile: Harness.Compiler.TestFileWithPath = {
+            unitName: fileName,
+            content: content,
+            path: ts.toPath(fileName, currentDirectory, getCanonicalFileName)
+        };
+
         const host = Harness.Compiler.createCompilerHost(
-            [
-                { unitName: Harness.Compiler.fourslashFileName, content: undefined },
-                { unitName: fileName, content: content }
-            ],
+            [ fourslashFile, testFile ],
             (fn, contents) => result = contents,
             ts.ScriptTarget.Latest,
-            Harness.IO.useCaseSensitiveFileNames());
+            useCaseSensitiveFileNames,
+            currentDirectory);
 
         const program = ts.createProgram([Harness.Compiler.fourslashFileName, fileName], { outFile: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);
 

src/harness/harness.ts

@@ -628,7 +628,7 @@ namespace Harness {
                 function getResolvedPathFromServer(path: string) {
                     const xhr = new XMLHttpRequest();
                     try {
-                        xhr.open("GET", path + "?resolve", false);
+                        xhr.open("GET", path + "?resolve", /*async*/ false);
                         xhr.send();
                     }
                     catch (e) {
@@ -647,7 +647,7 @@ namespace Harness {
                 export function getFileFromServerSync(url: string): XHRResponse {
                     const xhr = new XMLHttpRequest();
                     try {
-                        xhr.open("GET", url, false);
+                        xhr.open("GET", url, /*async*/ false);
                         xhr.send();
                     }
                     catch (e) {
@@ -662,7 +662,7 @@ namespace Harness {
                     const xhr = new XMLHttpRequest();
                     try {
                         const actionMsg = "?action=" + action;
-                        xhr.open("POST", url + actionMsg, false);
+                        xhr.open("POST", url + actionMsg, /*async*/ false);
                         xhr.setRequestHeader("Access-Control-Allow-Origin", "*");
                         xhr.send(contents);
                     }
@@ -903,41 +903,34 @@ namespace Harness {
         }
 
         export function createCompilerHost(
-            inputFiles: { unitName: string; content: string; }[],
+            inputFiles: TestFileWithPath[],
             writeFile: (fn: string, contents: string, writeByteOrderMark: boolean) => void,
             scriptTarget: ts.ScriptTarget,
             useCaseSensitiveFileNames: boolean,
             // the currentDirectory is needed for rwcRunner to passed in specified current directory to compiler host
-            currentDirectory?: string,
+            currentDirectory: string,
             newLineKind?: ts.NewLineKind): ts.CompilerHost {
 
             // Local get canonical file name function, that depends on passed in parameter for useCaseSensitiveFileNames
-            function getCanonicalFileName(fileName: string): string {
-                return useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
-            }
+            const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
 
-            const filemap: { [fileName: string]: ts.SourceFile; } = {};
-            const getCurrentDirectory = currentDirectory === undefined ? Harness.IO.getCurrentDirectory : () => currentDirectory;
+            const fileMap: ts.FileMap<ts.SourceFile> = ts.createFileMap<ts.SourceFile>();
 
             // Register input files
-            function register(file: { unitName: string; content: string; }) {
+            function register(file: TestFileWithPath) {
                 if (file.content !== undefined) {
                     const fileName = ts.normalizePath(file.unitName);
                     const sourceFile = createSourceFileAndAssertInvariants(fileName, file.content, scriptTarget);
-                    filemap[getCanonicalFileName(fileName)] = sourceFile;
-                    filemap[getCanonicalFileName(ts.getNormalizedAbsolutePath(fileName, getCurrentDirectory()))] = sourceFile;
+                    fileMap.set(file.path, sourceFile);
                 }
             };
             inputFiles.forEach(register);
 
             function getSourceFile(fn: string, languageVersion: ts.ScriptTarget) {
                 fn = ts.normalizePath(fn);
-                if (Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(fn))) {
-                    return filemap[getCanonicalFileName(fn)];
-                }
-                else if (currentDirectory) {
-                    const canonicalAbsolutePath = getCanonicalFileName(ts.getNormalizedAbsolutePath(fn, currentDirectory));
-                    return Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(canonicalAbsolutePath)) ? filemap[canonicalAbsolutePath] : undefined;
+                const path = ts.toPath(fn, currentDirectory, getCanonicalFileName);
+                if (fileMap.contains(path)) {
+                    return fileMap.get(path);
                 }
                 else if (fn === fourslashFileName) {
                     const tsFn = "tests/cases/fourslash/" + fourslashFileName;
@@ -959,7 +952,7 @@ namespace Harness {
                         Harness.IO.newLine();
 
             return {
-                getCurrentDirectory,
+                getCurrentDirectory: () => currentDirectory,
                 getSourceFile,
                 getDefaultLibFileName: options => defaultLibFileName,
                 writeFile,
@@ -1034,95 +1027,74 @@ namespace Harness {
             }
         }
 
-        export class HarnessCompiler {
-            private inputFiles: { unitName: string; content: string }[] = [];
-            private compileOptions: ts.CompilerOptions;
-            private settings: Harness.TestCaseParser.CompilerSettings = {};
+        export interface TestFile {
+            unitName: string;
+            content: string;
+        }
+        export interface TestFileWithPath extends TestFile {
+            path: ts.Path;
+        }
 
-            private lastErrors: ts.Diagnostic[];
+        export interface CompilationOutput {
+            result: CompilerResult;
+            program: ts.Program;
+            options: ts.CompilerOptions & HarnessOptions;
+        }
 
-            public reset() {
-                this.inputFiles = [];
-                this.settings = {};
-                this.lastErrors = [];
-            }
-
-            public reportCompilationErrors() {
-                return this.lastErrors;
-            }
-
-            public setCompilerSettings(tcSettings: Harness.TestCaseParser.CompilerSettings) {
-                this.settings = tcSettings;
-            }
-
-            public addInputFiles(files: { unitName: string; content: string }[]) {
-                files.forEach(file => this.addInputFile(file));
-            }
-
-            public addInputFile(file: { unitName: string; content: string }) {
-                this.inputFiles.push(file);
-            }
-
-            public setCompilerOptions(options?: ts.CompilerOptions) {
-                this.compileOptions = options || { noResolve: false };
-            }
-
-            public emitAll(ioHost?: IEmitterIOHost) {
-                this.compileFiles(this.inputFiles,
-                    /*otherFiles*/ [],
-                    /*onComplete*/ result => {
-                        result.files.forEach(writeFile);
-                        result.declFilesCode.forEach(writeFile);
-                        result.sourceMaps.forEach(writeFile);
-                    },
-                    /*settingsCallback*/ () => { },
-                    this.compileOptions);
-
-                function writeFile(file: GeneratedFile) {
-                    ioHost.writeFile(file.fileName, file.code, false);
-                }
-            }
-
-            public compileFiles(inputFiles: { unitName: string; content: string }[],
-                otherFiles: { unitName: string; content: string }[],
-                onComplete: (result: CompilerResult, program: ts.Program) => void,
-                settingsCallback?: (settings: ts.CompilerOptions) => void,
-                options?: ts.CompilerOptions & HarnessOptions,
+        export namespace HarnessCompiler {
+            export function compileFiles(
+                inputFiles: TestFile[],
+                otherFiles: TestFile[],
+                harnessSettings: TestCaseParser.CompilerSettings,
+                compilerOptions: ts.CompilerOptions,
                 // Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file
-                currentDirectory?: string) {
+                currentDirectory: string): CompilationOutput {
 
-                options = options || { noResolve: false };
+                const options: ts.CompilerOptions & HarnessOptions = compilerOptions ? ts.clone(compilerOptions) : { noResolve: false };
                 options.target = options.target || ts.ScriptTarget.ES3;
                 options.module = options.module || ts.ModuleKind.None;
                 options.newLine = options.newLine || ts.NewLineKind.CarriageReturnLineFeed;
                 options.noErrorTruncation = true;
                 options.skipDefaultLibCheck = true;
 
-                if (settingsCallback) {
-                    settingsCallback(null);
-                }
-
                 const newLine = "\r\n";
+                currentDirectory = currentDirectory || Harness.IO.getCurrentDirectory();
 
                 // Parse settings
-                setCompilerOptionsFromHarnessSetting(this.settings, options);
+                let useCaseSensitiveFileNames = Harness.IO.useCaseSensitiveFileNames();
+                if (harnessSettings) {
+                    setCompilerOptionsFromHarnessSetting(harnessSettings, options);
+                }
+                if (options.useCaseSensitiveFileNames !== undefined) {
+                    useCaseSensitiveFileNames = options.useCaseSensitiveFileNames;
+                }
+                const getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
+                const inputFilesWithPath = inputFiles.map(f => {
+                    return { unitName: f.unitName, content: f.content, path: ts.toPath(f.unitName, currentDirectory, getCanonicalFileName) };
+                });
+                const otherFilesWithPath = otherFiles.map(f => {
+                    return { unitName: f.unitName, content: f.content, path: ts.toPath(f.unitName, currentDirectory, getCanonicalFileName) };
+                });
 
                 // Files from built\local that are requested by test "@includeBuiltFiles" to be in the context.
                 // Treat them as library files, so include them in build, but not in baselines.
-                const includeBuiltFiles: { unitName: string; content: string }[] = [];
+                const includeBuiltFiles: TestFileWithPath[] = [];
                 if (options.includeBuiltFile) {
                     const builtFileName = libFolder + options.includeBuiltFile;
-                    includeBuiltFiles.push({ unitName: builtFileName, content: normalizeLineEndings(IO.readFile(builtFileName), newLine) });
+                    const builtFile: TestFileWithPath = {
+                        unitName: builtFileName,
+                        content: normalizeLineEndings(IO.readFile(builtFileName), newLine),
+                        path: ts.toPath(builtFileName, currentDirectory, getCanonicalFileName)
+                    };
+                    includeBuiltFiles.push(builtFile);
                 }
 
-                const useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : Harness.IO.useCaseSensitiveFileNames();
-
                 const fileOutputs: GeneratedFile[] = [];
 
                 const programFiles = inputFiles.concat(includeBuiltFiles).map(file => file.unitName);
 
                 const compilerHost = createCompilerHost(
-                    inputFiles.concat(includeBuiltFiles).concat(otherFiles),
+                    inputFilesWithPath.concat(includeBuiltFiles).concat(otherFilesWithPath),
                     (fn, contents, writeByteOrderMark) => fileOutputs.push({ fileName: fn, code: contents, writeByteOrderMark: writeByteOrderMark }),
                     options.target, useCaseSensitiveFileNames, currentDirectory, options.newLine);
                 const program = ts.createProgram(programFiles, options, compilerHost);
@@ -1130,40 +1102,35 @@ namespace Harness {
                 const emitResult = program.emit();
 
                 const errors = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
-                this.lastErrors = errors;
 
                 const result = new CompilerResult(fileOutputs, errors, program, Harness.IO.getCurrentDirectory(), emitResult.sourceMaps);
-                onComplete(result, program);
-
-                return options;
+                return { result, program, options };
             }
 
-            public compileDeclarationFiles(inputFiles: { unitName: string; content: string; }[],
-                otherFiles: { unitName: string; content: string; }[],
+            export function compileDeclarationFiles(inputFiles: TestFile[],
+                otherFiles: TestFile[],
                 result: CompilerResult,
-                settingsCallback?: (settings: ts.CompilerOptions) => void,
-                options?: ts.CompilerOptions,
+                harnessSettings: TestCaseParser.CompilerSettings & HarnessOptions,
+                options: ts.CompilerOptions,
                 // Current directory is needed for rwcRunner to be able to use currentDirectory defined in json file
-                currentDirectory?: string) {
+                currentDirectory: string) {
                 if (options.declaration && result.errors.length === 0 && result.declFilesCode.length !== result.files.length) {
                     throw new Error("There were no errors and declFiles generated did not match number of js files generated");
                 }
 
-                const declInputFiles: { unitName: string; content: string }[] = [];
-                const declOtherFiles: { unitName: string; content: string }[] = [];
-                let declResult: Harness.Compiler.CompilerResult;
+                const declInputFiles: TestFile[] = [];
+                const declOtherFiles: TestFile[] = [];
 
                 // if the .d.ts is non-empty, confirm it compiles correctly as well
                 if (options.declaration && result.errors.length === 0 && result.declFilesCode.length > 0) {
                     ts.forEach(inputFiles, file => addDtsFile(file, declInputFiles));
                     ts.forEach(otherFiles, file => addDtsFile(file, declOtherFiles));
-                    this.compileFiles(declInputFiles, declOtherFiles, function (compileResult) { declResult = compileResult; },
-                        settingsCallback, options, currentDirectory);
+                    const output = this.compileFiles(declInputFiles, declOtherFiles, harnessSettings, options, currentDirectory);
 
-                    return { declInputFiles, declOtherFiles, declResult };
+                    return { declInputFiles, declOtherFiles, declResult: output.result };
                 }
 
-                function addDtsFile(file: { unitName: string; content: string }, dtsFiles: { unitName: string; content: string }[]) {
+                function addDtsFile(file: TestFile, dtsFiles: TestFile[]) {
                     if (isDTS(file.unitName)) {
                         dtsFiles.push(file);
                     }
@@ -1200,7 +1167,7 @@ namespace Harness {
                         return ts.forEach(result.declFilesCode, declFile => declFile.fileName === dTsFileName ? declFile : undefined);
                     }
 
-                    function findUnit(fileName: string, units: { unitName: string; content: string; }[]) {
+                    function findUnit(fileName: string, units: TestFile[]) {
                         return ts.forEach(units, unit => unit.unitName === fileName ? unit : undefined);
                     }
                 }
@@ -1230,7 +1197,7 @@ namespace Harness {
             return errorOutput;
         }
 
-        export function getErrorBaseline(inputFiles: { unitName: string; content: string }[], diagnostics: ts.Diagnostic[]) {
+        export function getErrorBaseline(inputFiles: TestFile[], diagnostics: ts.Diagnostic[]) {
             diagnostics.sort(ts.compareDiagnostics);
             const outputLines: string[] = [];
             // Count up all errors that were found in files other than lib.d.ts so we don't miss any
@@ -1371,16 +1338,6 @@ namespace Harness {
             }
         }
 
-        /** The harness' compiler instance used when tests are actually run. Reseting or changing settings of this compiler instance must be done within a test case (i.e., describe/it) */
-        let harnessCompiler: HarnessCompiler;
-
-        /** Returns the singleton harness compiler instance for generating and running tests.
-            If required a fresh compiler instance will be created, otherwise the existing singleton will be re-used.
-        */
-        export function getCompiler() {
-            return harnessCompiler = harnessCompiler || new HarnessCompiler();
-        }
-
         // This does not need to exist strictly speaking, but many tests will need to be updated if it's removed
         export function compileString(code: string, unitName: string, callback: (result: CompilerResult) => void) {
             // NEWTODO: Re-implement 'compileString'
@@ -1711,12 +1668,9 @@ namespace Harness {
         return filePath.indexOf(Harness.libFolder) === 0;
     }
 
-    export function getDefaultLibraryFile(io: Harness.IO): { unitName: string, content: string } {
+    export function getDefaultLibraryFile(io: Harness.IO): Harness.Compiler.TestFile {
         const libFile = Harness.userSpecifiedRoot + Harness.libFolder + "lib.d.ts";
-        return {
-            unitName: libFile,
-            content: io.readFile(libFile)
-        };
+        return { unitName: libFile, content: io.readFile(libFile) };
     }
 
     if (Error) (<any>Error).stackTraceLimit = 1;

src/harness/harnessLanguageService.ts

@@ -153,7 +153,7 @@ namespace Harness.LanguageService {
             throw new Error("No script with name '" + fileName + "'");
         }
 
-        public openFile(fileName: string): void {
+        public openFile(fileName: string, content?: string): void {
         }
 
         /**
@@ -493,9 +493,9 @@ namespace Harness.LanguageService {
             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) {

src/harness/loggedIO.ts

@@ -174,7 +174,7 @@ namespace Playback {
                     return true;
                 }
                 else {
-                    return findResultByFields(replayLog.fileExists, { path }, false);
+                    return findResultByFields(replayLog.fileExists, { path }, /*defaultValue*/ false);
                 }
             })
         );

src/harness/projectsRunner.ts

@@ -349,7 +349,7 @@ class ProjectRunner extends RunnerBase {
             const inputFiles = ts.map(ts.filter(compilerResult.program.getSourceFiles(),
                 sourceFile => sourceFile.fileName !== "lib.d.ts"),
                 sourceFile => {
-                    return { unitName: RunnerBase.removeFullPaths(sourceFile.fileName), content: sourceFile.text };
+                    return { unitName: RunnerBase.removeFullPaths(sourceFile.fileName), content: sourceFile.text, };
                 });
 
             return Harness.Compiler.getErrorBaseline(inputFiles, compilerResult.errors);

src/harness/rwcRunner.ts

@@ -27,8 +27,8 @@ namespace RWC {
 
     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 = {
@@ -55,7 +55,6 @@ namespace RWC {
             });
 
             it("can compile", () => {
-                const harnessCompiler = Harness.Compiler.getCompiler();
                 let opts: ts.ParsedCommandLine;
 
                 const ioLog: IOLog = JSON.parse(Harness.IO.readFile(jsonPath));
@@ -71,8 +70,6 @@ namespace RWC {
                 });
 
                 runWithIOLog(ioLog, oldIO => {
-                    harnessCompiler.reset();
-
                     let fileNames = opts.fileNames;
 
                     const tsconfigFile = ts.forEach(ioLog.filesRead, f => isTsConfigFile(f) ? f : undefined);
@@ -128,17 +125,21 @@ namespace RWC {
                     opts.options.noLib = true;
 
                     // Emit the results
-                    compilerOptions = harnessCompiler.compileFiles(
+                    compilerOptions = null;
+                    const output = Harness.Compiler.HarnessCompiler.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) {
+                function getHarnessCompilerInputUnit(fileName: string): Harness.Compiler.TestFile {
                     const unitName = ts.normalizeSlashes(Harness.IO.resolvePath(fileName));
                     let content: string = null;
                     try {
@@ -201,8 +202,9 @@ namespace 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", () => {
-                        const declFileCompilationResult = Harness.Compiler.getCompiler().compileDeclarationFiles(inputFiles, otherFiles, compilerResult,
-                            /*settingscallback*/ undefined, compilerOptions, currentDirectory);
+                        const declFileCompilationResult = Harness.Compiler.HarnessCompiler.compileDeclarationFiles(
+                            inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
+
                         if (declFileCompilationResult.declResult.errors.length === 0) {
                             return null;
                         }

src/harness/sourceMapRecorder.ts

@@ -190,7 +190,7 @@ namespace Harness.SourceMapRecoder {
                 return { error: errorDecodeOfEncodedMapping, sourceMapSpan: decodeOfEncodedMapping };
             }
 
-            createErrorIfCondition(true, "No encoded entry found");
+            createErrorIfCondition(/*condition*/ true, "No encoded entry found");
         }
 
         export function hasCompletedDecoding() {

src/harness/test262Runner.ts

@@ -5,9 +5,9 @@
 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 = {
@@ -31,7 +31,7 @@ class Test262BaselineRunner extends RunnerBase {
             let testState: {
                 filename: string;
                 compilerResult: Harness.Compiler.CompilerResult;
-                inputFiles: { unitName: string; content: string }[];
+                inputFiles: Harness.Compiler.TestFile[];
                 program: ts.Program;
             };
 
@@ -40,8 +40,9 @@ class Test262BaselineRunner extends RunnerBase {
                 const testFilename = ts.removeFileExtension(filePath).replace(/\//g, "_") + ".test";
                 const testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, testFilename);
 
-                const 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
@@ -52,10 +53,15 @@ class Test262BaselineRunner extends RunnerBase {
                     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.HarnessCompiler.compileFiles(
+                    [Test262BaselineRunner.helperFile].concat(inputFiles),
+                    /*otherFiles*/ [],
+                    /* harnessOptions */ undefined,
+                    Test262BaselineRunner.options,
+                    /* currentDirectory */ undefined
+                    );
+                testState.compilerResult = output.result;
+                testState.program = output.program;
             });
 
             after(() => {

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

@@ -388,7 +388,7 @@ namespace ts.server {
         }
 
         openReferencedFile(filename: string) {
-            return this.projectService.openFile(filename, false);
+            return this.projectService.openFile(filename, /*openedByClient*/ false);
         }
 
         getRootFiles() {
@@ -1006,14 +1006,15 @@ namespace ts.server {
 
         /**
          * @param filename is absolute pathname
+         * @param fileContent is a known version of the file content that is more up to date than the one on disk
          */
-        openFile(fileName: string, openedByClient: boolean) {
+        openFile(fileName: string, openedByClient: boolean, fileContent?: string) {
             fileName = ts.normalizePath(fileName);
             let info = ts.lookUp(this.filenameToScriptInfo, fileName);
             if (!info) {
                 let content: string;
                 if (this.host.fileExists(fileName)) {
-                    content = this.host.readFile(fileName);
+                    content = fileContent || this.host.readFile(fileName);
                 }
                 if (!content) {
                     if (openedByClient) {
@@ -1030,6 +1031,9 @@ namespace ts.server {
                 }
             }
             if (info) {
+                if (fileContent) {
+                    info.svc.reload(fileContent);
+                }
                 if (openedByClient) {
                     info.isOpen = true;
                 }
@@ -1060,10 +1064,11 @@ namespace ts.server {
         /**
          * Open file whose contents is managed by the client
          * @param filename is absolute pathname
+         * @param fileContent is a known version of the file content that is more up to date than the one on disk
          */
-        openClientFile(fileName: string) {
+        openClientFile(fileName: string, fileContent?: string) {
             this.openOrUpdateConfiguredProjectForFile(fileName);
-            const info = this.openFile(fileName, true);
+            const info = this.openFile(fileName, /*openedByClient*/ true, fileContent);
             this.addOpenFile(info);
             this.printProjects();
             return info;
@@ -1272,7 +1277,7 @@ namespace ts.server {
                     for (const fileName of fileNamesToAdd) {
                         let info = this.getScriptInfo(fileName);
                         if (!info) {
-                            info = this.openFile(fileName, false);
+                            info = this.openFile(fileName, /*openedByClient*/ false);
                         }
                         else {
                             // if the root file was opened by client, it would belong to either 

src/server/protocol.d.ts

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

src/server/session.ts

@@ -532,9 +532,13 @@ namespace ts.server {
             };
         }
 
-        private openClientFile(fileName: string) {
+        /**
+         * @param fileName is the name of the file to be opened
+         * @param fileContent is a version of the file content that is known to be more up to date than the one on disk
+         */
+        private openClientFile(fileName: string, fileContent?: string) {
             const file = ts.normalizePath(fileName);
-            this.projectService.openClientFile(file);
+            this.projectService.openClientFile(file, fileContent);
         }
 
         private getQuickInfo(line: number, offset: number, fileName: string): protocol.QuickInfoResponseBody {
@@ -897,7 +901,7 @@ namespace ts.server {
         }
 
         getDiagnosticsForProject(delay: number, fileName: string) {
-            const { configFileName, fileNames } = this.getProjectInfo(fileName, true);
+            const { configFileName, fileNames } = this.getProjectInfo(fileName, /*needFileNameList*/ true);
             // No need to analyze lib.d.ts
             let fileNamesInProject = fileNames.filter((value, index, array) => value.indexOf("lib.d.ts") < 0);
 
@@ -968,7 +972,7 @@ namespace ts.server {
             },
             [CommandNames.Open]: (request: protocol.Request) => {
                 const openArgs = <protocol.OpenRequestArgs>request.arguments;
-                this.openClientFile(openArgs.file);
+                this.openClientFile(openArgs.file, openArgs.fileContent);
                 return {responseRequired: false};
             },
             [CommandNames.Quickinfo]: (request: protocol.Request) => {

src/services/services.ts

@@ -2847,8 +2847,11 @@ namespace ts {
             }
 
             function sourceFileUpToDate(sourceFile: SourceFile): boolean {
+                if (!sourceFile) {
+                    return false;
+                }
                 let path = sourceFile.path || toPath(sourceFile.fileName, currentDirectory, getCanonicalFileName);
-                return sourceFile && sourceFile.version === hostCache.getVersion(path);
+                return sourceFile.version === hostCache.getVersion(path);
             }
 
             function programUpToDate(): boolean {

tests/baselines/reference/ambientClassDeclarationWithExtends.js

@@ -1,6 +1,40 @@
-//// [ambientClassDeclarationWithExtends.ts]
+//// [tests/cases/compiler/ambientClassDeclarationWithExtends.ts] ////
+
+//// [ambientClassDeclarationExtends_singleFile.ts]
 declare class A { }
 declare class B extends A { }
+
+declare class C {
+    public foo;
+}
+namespace D { var x; }
+declare class D extends C { }
+
+var d: C = new D();
+
+//// [ambientClassDeclarationExtends_file1.ts]
+
+declare class E {
+    public bar;
+}
+namespace F { var y; }
+
+//// [ambientClassDeclarationExtends_file2.ts]
+
+declare class F extends E { }
+var f: E = new F();
 
 
-//// [ambientClassDeclarationWithExtends.js]
+//// [ambientClassDeclarationExtends_singleFile.js]
+var D;
+(function (D) {
+    var x;
+})(D || (D = {}));
+var d = new D();
+//// [ambientClassDeclarationExtends_file1.js]
+var F;
+(function (F) {
+    var y;
+})(F || (F = {}));
+//// [ambientClassDeclarationExtends_file2.js]
+var f = new F();

tests/baselines/reference/ambientClassDeclarationWithExtends.symbols

@@ -1,8 +1,50 @@
-=== tests/cases/compiler/ambientClassDeclarationWithExtends.ts ===
+=== tests/cases/compiler/ambientClassDeclarationExtends_singleFile.ts ===
 declare class A { }
->A : Symbol(A, Decl(ambientClassDeclarationWithExtends.ts, 0, 0))
+>A : Symbol(A, Decl(ambientClassDeclarationExtends_singleFile.ts, 0, 0))
 
 declare class B extends A { }
->B : Symbol(B, Decl(ambientClassDeclarationWithExtends.ts, 0, 19))
->A : Symbol(A, Decl(ambientClassDeclarationWithExtends.ts, 0, 0))
+>B : Symbol(B, Decl(ambientClassDeclarationExtends_singleFile.ts, 0, 19))
+>A : Symbol(A, Decl(ambientClassDeclarationExtends_singleFile.ts, 0, 0))
+
+declare class C {
+>C : Symbol(C, Decl(ambientClassDeclarationExtends_singleFile.ts, 1, 29))
+
+    public foo;
+>foo : Symbol(foo, Decl(ambientClassDeclarationExtends_singleFile.ts, 3, 17))
+}
+namespace D { var x; }
+>D : Symbol(D, Decl(ambientClassDeclarationExtends_singleFile.ts, 5, 1), Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 22))
+>x : Symbol(x, Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 17))
+
+declare class D extends C { }
+>D : Symbol(D, Decl(ambientClassDeclarationExtends_singleFile.ts, 5, 1), Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 22))
+>C : Symbol(C, Decl(ambientClassDeclarationExtends_singleFile.ts, 1, 29))
+
+var d: C = new D();
+>d : Symbol(d, Decl(ambientClassDeclarationExtends_singleFile.ts, 9, 3))
+>C : Symbol(C, Decl(ambientClassDeclarationExtends_singleFile.ts, 1, 29))
+>D : Symbol(D, Decl(ambientClassDeclarationExtends_singleFile.ts, 5, 1), Decl(ambientClassDeclarationExtends_singleFile.ts, 6, 22))
+
+=== tests/cases/compiler/ambientClassDeclarationExtends_file1.ts ===
+
+declare class E {
+>E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0))
+
+    public bar;
+>bar : Symbol(bar, Decl(ambientClassDeclarationExtends_file1.ts, 1, 17))
+}
+namespace F { var y; }
+>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0))
+>y : Symbol(y, Decl(ambientClassDeclarationExtends_file1.ts, 4, 17))
+
+=== tests/cases/compiler/ambientClassDeclarationExtends_file2.ts ===
+
+declare class F extends E { }
+>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0))
+>E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0))
+
+var f: E = new F();
+>f : Symbol(f, Decl(ambientClassDeclarationExtends_file2.ts, 2, 3))
+>E : Symbol(E, Decl(ambientClassDeclarationExtends_file1.ts, 0, 0))
+>F : Symbol(F, Decl(ambientClassDeclarationExtends_file1.ts, 3, 1), Decl(ambientClassDeclarationExtends_file2.ts, 0, 0))
 

tests/baselines/reference/ambientClassDeclarationWithExtends.types

@@ -1,4 +1,4 @@
-=== tests/cases/compiler/ambientClassDeclarationWithExtends.ts ===
+=== tests/cases/compiler/ambientClassDeclarationExtends_singleFile.ts ===
 declare class A { }
 >A : A
 
@@ -6,3 +6,47 @@ declare class B extends A { }
 >B : B
 >A : A
 
+declare class C {
+>C : C
+
+    public foo;
+>foo : any
+}
+namespace D { var x; }
+>D : typeof D
+>x : any
+
+declare class D extends C { }
+>D : D
+>C : C
+
+var d: C = new D();
+>d : C
+>C : C
+>new D() : D
+>D : typeof D
+
+=== tests/cases/compiler/ambientClassDeclarationExtends_file1.ts ===
+
+declare class E {
+>E : E
+
+    public bar;
+>bar : any
+}
+namespace F { var y; }
+>F : typeof F
+>y : any
+
+=== tests/cases/compiler/ambientClassDeclarationExtends_file2.ts ===
+
+declare class F extends E { }
+>F : F
+>E : E
+
+var f: E = new F();
+>f : E
+>E : E
+>new F() : F
+>F : typeof F
+

tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.js

@@ -0,0 +1,27 @@
+//// [checkSwitchStatementIfCaseTypeIsString.ts]
+declare function use(a: any): void;
+
+class A {
+    doIt(x: Array<string>): void {
+        x.forEach((v) => {
+            switch(v) {
+                case "test": use(this);
+            }
+        });
+    }
+}
+
+//// [checkSwitchStatementIfCaseTypeIsString.js]
+var A = (function () {
+    function A() {
+    }
+    A.prototype.doIt = function (x) {
+        var _this = this;
+        x.forEach(function (v) {
+            switch (v) {
+                case "test": use(_this);
+            }
+        });
+    };
+    return A;
+})();

tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.symbols

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/checkSwitchStatementIfCaseTypeIsString.ts ===
+declare function use(a: any): void;
+>use : Symbol(use, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 0, 0))
+>a : Symbol(a, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 0, 21))
+
+class A {
+>A : Symbol(A, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 0, 35))
+
+    doIt(x: Array<string>): void {
+>doIt : Symbol(doIt, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 2, 9))
+>x : Symbol(x, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 3, 9))
+>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+        x.forEach((v) => {
+>x.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 3, 9))
+>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --))
+>v : Symbol(v, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 4, 19))
+
+            switch(v) {
+>v : Symbol(v, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 4, 19))
+
+                case "test": use(this);
+>use : Symbol(use, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 0, 0))
+>this : Symbol(A, Decl(checkSwitchStatementIfCaseTypeIsString.ts, 0, 35))
+            }
+        });
+    }
+}

tests/baselines/reference/checkSwitchStatementIfCaseTypeIsString.types

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/checkSwitchStatementIfCaseTypeIsString.ts ===
+declare function use(a: any): void;
+>use : (a: any) => void
+>a : any
+
+class A {
+>A : A
+
+    doIt(x: Array<string>): void {
+>doIt : (x: string[]) => void
+>x : string[]
+>Array : T[]
+
+        x.forEach((v) => {
+>x.forEach((v) => {            switch(v) {                case "test": use(this);            }        }) : void
+>x.forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>x : string[]
+>forEach : (callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void
+>(v) => {            switch(v) {                case "test": use(this);            }        } : (v: string) => void
+>v : string
+
+            switch(v) {
+>v : string
+
+                case "test": use(this);
+>"test" : string
+>use(this) : void
+>use : (a: any) => void
+>this : this
+            }
+        });
+    }
+}

tests/baselines/reference/getEmitOutputTsxFile_React.baseline

@@ -17,9 +17,9 @@ declare class Bar {
 
 EmitSkipped: false
 FileName : tests/cases/fourslash/inputFile2.js.map
-{"version":3,"file":"inputFile2.js","sourceRoot":"","sources":["inputFile2.tsx"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,QAAQ,CAAC;AACjB,IAAI,CAAC,GAAG,qBAAC,GAAG,KAAC,IAAI,GAAG,CAAE,EAAG,CAAA"}FileName : tests/cases/fourslash/inputFile2.js
+{"version":3,"file":"inputFile2.js","sourceRoot":"","sources":["inputFile2.tsx"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,QAAQ,CAAC;AACjB,IAAI,CAAC,GAAG,qBAAC,GAAG,IAAC,IAAI,EAAG,CAAE,EAAG,CAAA"}FileName : tests/cases/fourslash/inputFile2.js
 var y = "my div";
-var x = React.createElement("div", {"name": y});
+var x = React.createElement("div", {name: y});
 //# sourceMappingURL=inputFile2.js.mapFileName : tests/cases/fourslash/inputFile2.d.ts
 declare var y: string;
 declare var x: any;

tests/baselines/reference/inlineSourceMap2.errors.txt

@@ -1,12 +1,10 @@
 error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'.
 error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'.
-error TS5053: Option 'sourceRoot' cannot be specified with option 'inlineSourceMap'.
 tests/cases/compiler/inlineSourceMap2.ts(5,1): error TS2304: Cannot find name 'console'.
 
 
 !!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'.
 !!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'.
-!!! error TS5053: Option 'sourceRoot' cannot be specified with option 'inlineSourceMap'.
 ==== tests/cases/compiler/inlineSourceMap2.ts (1 errors) ====
     
     // configuration errors

tests/baselines/reference/keywordInJsxIdentifier.js

@@ -9,6 +9,6 @@ declare var React: any;
 
 //// [keywordInJsxIdentifier.js]
 React.createElement("foo", {"class-id": true});
-React.createElement("foo", {"class": true});
+React.createElement("foo", {class: true});
 React.createElement("foo", {"class-id": "1"});
-React.createElement("foo", {"class": "1"});
+React.createElement("foo", {class: "1"});

tests/baselines/reference/mixedStaticAndInstanceClassMembers.errors.txt

@@ -0,0 +1,27 @@
+tests/cases/compiler/mixedStaticAndInstanceClassMembers.ts(4,5): error TS2387: Function overload must be static.
+tests/cases/compiler/mixedStaticAndInstanceClassMembers.ts(12,12): error TS2388: Function overload must not be static.
+tests/cases/compiler/mixedStaticAndInstanceClassMembers.ts(13,5): error TS2387: Function overload must be static.
+
+
+==== tests/cases/compiler/mixedStaticAndInstanceClassMembers.ts (3 errors) ====
+    class A {
+        f() {}
+        static m1 (a: string): void;
+        m1 (a: number): void;
+        ~~
+!!! error TS2387: Function overload must be static.
+        m1 (a: any): void {
+        }
+    }
+    
+    class B {
+        f() {}
+        m1 (a: string): void;
+        static m1 (a: number): void;
+               ~~
+!!! error TS2388: Function overload must not be static.
+        m1 (a: any): void {
+        ~~
+!!! error TS2387: Function overload must be static.
+        }
+    }

tests/baselines/reference/mixedStaticAndInstanceClassMembers.js

@@ -0,0 +1,34 @@
+//// [mixedStaticAndInstanceClassMembers.ts]
+class A {
+    f() {}
+    static m1 (a: string): void;
+    m1 (a: number): void;
+    m1 (a: any): void {
+    }
+}
+
+class B {
+    f() {}
+    m1 (a: string): void;
+    static m1 (a: number): void;
+    m1 (a: any): void {
+    }
+}
+
+//// [mixedStaticAndInstanceClassMembers.js]
+var A = (function () {
+    function A() {
+    }
+    A.prototype.f = function () { };
+    A.prototype.m1 = function (a) {
+    };
+    return A;
+})();
+var B = (function () {
+    function B() {
+    }
+    B.prototype.f = function () { };
+    B.prototype.m1 = function (a) {
+    };
+    return B;
+})();

tests/baselines/reference/nonMergedDeclarationsAndOverloads.errors.txt

@@ -0,0 +1,23 @@
+tests/cases/compiler/nonMergedDeclarationsAndOverloads.ts(2,5): error TS2300: Duplicate identifier 'm1'.
+tests/cases/compiler/nonMergedDeclarationsAndOverloads.ts(4,5): error TS2300: Duplicate identifier 'm1'.
+tests/cases/compiler/nonMergedDeclarationsAndOverloads.ts(5,5): error TS2300: Duplicate identifier 'm1'.
+tests/cases/compiler/nonMergedDeclarationsAndOverloads.ts(6,5): error TS2300: Duplicate identifier 'm1'.
+
+
+==== tests/cases/compiler/nonMergedDeclarationsAndOverloads.ts (4 errors) ====
+    class A {
+        m1: string;
+        ~~
+!!! error TS2300: Duplicate identifier 'm1'.
+        f() {}
+        m1 (a: string): void;
+        ~~
+!!! error TS2300: Duplicate identifier 'm1'.
+        m1 (a: number): void;
+        ~~
+!!! error TS2300: Duplicate identifier 'm1'.
+        m1 (a: any): void {
+        ~~
+!!! error TS2300: Duplicate identifier 'm1'.
+        }
+    }

tests/baselines/reference/nonMergedDeclarationsAndOverloads.js

@@ -0,0 +1,19 @@
+//// [nonMergedDeclarationsAndOverloads.ts]
+class A {
+    m1: string;
+    f() {}
+    m1 (a: string): void;
+    m1 (a: number): void;
+    m1 (a: any): void {
+    }
+}
+
+//// [nonMergedDeclarationsAndOverloads.js]
+var A = (function () {
+    function A() {
+    }
+    A.prototype.f = function () { };
+    A.prototype.m1 = function (a) {
+    };
+    return A;
+})();

tests/baselines/reference/optionsInlineSourceMapMapRoot.errors.txt

@@ -0,0 +1,9 @@
+error TS5052: Option 'mapRoot' cannot be specified without specifying option 'sourceMap'.
+error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'.
+
+
+!!! error TS5052: Option 'mapRoot' cannot be specified without specifying option 'sourceMap'.
+!!! error TS5053: Option 'mapRoot' cannot be specified with option 'inlineSourceMap'.
+==== tests/cases/compiler/optionsInlineSourceMapMapRoot.ts (0 errors) ====
+    
+    var a = 10;

tests/baselines/reference/optionsInlineSourceMapMapRoot.js

@@ -0,0 +1,7 @@
+//// [optionsInlineSourceMapMapRoot.ts]
+
+var a = 10;
+
+//// [optionsInlineSourceMapMapRoot.js]
+var a = 10;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ==

tests/baselines/reference/optionsInlineSourceMapMapRoot.sourcemap.txt

@@ -0,0 +1,33 @@
+===================================================================
+JsFile: optionsInlineSourceMapMapRoot.js
+mapUrl: local/optionsInlineSourceMapMapRoot.js.map
+sourceRoot: 
+sources: ../optionsInlineSourceMapMapRoot.ts
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/optionsInlineSourceMapMapRoot.js
+sourceFile:../optionsInlineSourceMapMapRoot.ts
+-------------------------------------------------------------------
+>>>var a = 10;
+1 >
+2 >^^^^
+3 >    ^
+4 >     ^^^
+5 >        ^^
+6 >          ^
+7 >           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+  >
+2 >var 
+3 >    a
+4 >      = 
+5 >        10
+6 >          ;
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0)
+3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0)
+4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0)
+5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0)
+6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcE1hcFJvb3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9vcHRpb25zSW5saW5lU291cmNlTWFwTWFwUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ==

tests/baselines/reference/optionsInlineSourceMapSourceRoot.js

@@ -0,0 +1,7 @@
+//// [optionsInlineSourceMapSourceRoot.ts]
+
+var a = 10;
+
+//// [optionsInlineSourceMapSourceRoot.js]
+var a = 10;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ==

tests/baselines/reference/optionsInlineSourceMapSourceRoot.sourcemap.txt

@@ -0,0 +1,33 @@
+===================================================================
+JsFile: optionsInlineSourceMapSourceRoot.js
+mapUrl: optionsInlineSourceMapSourceRoot.js.map
+sourceRoot: local/
+sources: optionsInlineSourceMapSourceRoot.ts
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/optionsInlineSourceMapSourceRoot.js
+sourceFile:optionsInlineSourceMapSourceRoot.ts
+-------------------------------------------------------------------
+>>>var a = 10;
+1 >
+2 >^^^^
+3 >    ^
+4 >     ^^^
+5 >        ^^
+6 >          ^
+7 >           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+  >
+2 >var 
+3 >    a
+4 >      = 
+5 >        10
+6 >          ;
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0)
+3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0)
+4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0)
+5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0)
+6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZVJvb3QuanMiLCJzb3VyY2VSb290IjoibG9jYWwvIiwic291cmNlcyI6WyJvcHRpb25zSW5saW5lU291cmNlTWFwU291cmNlUm9vdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMifQ==

tests/baselines/reference/optionsInlineSourceMapSourceRoot.symbols

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts ===
+
+var a = 10;
+>a : Symbol(a, Decl(optionsInlineSourceMapSourceRoot.ts, 1, 3))
+

tests/baselines/reference/optionsInlineSourceMapSourceRoot.types

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts ===
+
+var a = 10;
+>a : number
+>10 : number
+

tests/baselines/reference/optionsInlineSourceMapSourcemap.errors.txt

@@ -0,0 +1,7 @@
+error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'.
+
+
+!!! error TS5053: Option 'sourceMap' cannot be specified with option 'inlineSourceMap'.
+==== tests/cases/compiler/optionsInlineSourceMapSourcemap.ts (0 errors) ====
+    
+    var a = 10;

tests/baselines/reference/optionsInlineSourceMapSourcemap.js

@@ -0,0 +1,7 @@
+//// [optionsInlineSourceMapSourcemap.ts]
+
+var a = 10;
+
+//// [optionsInlineSourceMapSourcemap.js]
+var a = 10;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0=

tests/baselines/reference/optionsInlineSourceMapSourcemap.sourcemap.txt

@@ -0,0 +1,33 @@
+===================================================================
+JsFile: optionsInlineSourceMapSourcemap.js
+mapUrl: optionsInlineSourceMapSourcemap.js.map
+sourceRoot: 
+sources: optionsInlineSourceMapSourcemap.ts
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/optionsInlineSourceMapSourcemap.js
+sourceFile:optionsInlineSourceMapSourcemap.ts
+-------------------------------------------------------------------
+>>>var a = 10;
+1 >
+2 >^^^^
+3 >    ^
+4 >     ^^^
+5 >        ^^
+6 >          ^
+7 >           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+  >
+2 >var 
+3 >    a
+4 >      = 
+5 >        10
+6 >          ;
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0)
+3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0)
+4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0)
+5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0)
+6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9uc0lubGluZVNvdXJjZU1hcFNvdXJjZW1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm9wdGlvbnNJbmxpbmVTb3VyY2VNYXBTb3VyY2VtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDIn0=

tests/baselines/reference/optionsSourcemapInlineSources.js

@@ -0,0 +1,7 @@
+//// [optionsSourcemapInlineSources.ts]
+
+var a = 10;
+
+//// [optionsSourcemapInlineSources.js]
+var a = 10;
+//# sourceMappingURL=optionsSourcemapInlineSources.js.map

tests/baselines/reference/optionsSourcemapInlineSources.js.map

@@ -0,0 +1,2 @@
+//// [optionsSourcemapInlineSources.js.map]
+{"version":3,"file":"optionsSourcemapInlineSources.js","sourceRoot":"","sources":["optionsSourcemapInlineSources.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]}

tests/baselines/reference/optionsSourcemapInlineSources.sourcemap.txt

@@ -0,0 +1,34 @@
+===================================================================
+JsFile: optionsSourcemapInlineSources.js
+mapUrl: optionsSourcemapInlineSources.js.map
+sourceRoot: 
+sources: optionsSourcemapInlineSources.ts
+sourcesContent: ["\nvar a = 10;"]
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/optionsSourcemapInlineSources.js
+sourceFile:optionsSourcemapInlineSources.ts
+-------------------------------------------------------------------
+>>>var a = 10;
+1 >
+2 >^^^^
+3 >    ^
+4 >     ^^^
+5 >        ^^
+6 >          ^
+7 >           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+  >
+2 >var 
+3 >    a
+4 >      = 
+5 >        10
+6 >          ;
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0)
+3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0)
+4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0)
+5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0)
+6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=optionsSourcemapInlineSources.js.map

tests/baselines/reference/optionsSourcemapInlineSources.symbols

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/optionsSourcemapInlineSources.ts ===
+
+var a = 10;
+>a : Symbol(a, Decl(optionsSourcemapInlineSources.ts, 1, 3))
+

tests/baselines/reference/optionsSourcemapInlineSources.types

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/optionsSourcemapInlineSources.ts ===
+
+var a = 10;
+>a : number
+>10 : number
+

tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js

@@ -0,0 +1,7 @@
+//// [optionsSourcemapInlineSourcesMapRoot.ts]
+
+var a = 10;
+
+//// [optionsSourcemapInlineSourcesMapRoot.js]
+var a = 10;
+//# sourceMappingURL=local/optionsSourcemapInlineSourcesMapRoot.js.map

tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.js.map

@@ -0,0 +1,2 @@
+//// [optionsSourcemapInlineSourcesMapRoot.js.map]
+{"version":3,"file":"optionsSourcemapInlineSourcesMapRoot.js","sourceRoot":"","sources":["../optionsSourcemapInlineSourcesMapRoot.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]}

tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.sourcemap.txt

@@ -0,0 +1,34 @@
+===================================================================
+JsFile: optionsSourcemapInlineSourcesMapRoot.js
+mapUrl: local/optionsSourcemapInlineSourcesMapRoot.js.map
+sourceRoot: 
+sources: ../optionsSourcemapInlineSourcesMapRoot.ts
+sourcesContent: ["\nvar a = 10;"]
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.js
+sourceFile:../optionsSourcemapInlineSourcesMapRoot.ts
+-------------------------------------------------------------------
+>>>var a = 10;
+1 >
+2 >^^^^
+3 >    ^
+4 >     ^^^
+5 >        ^^
+6 >          ^
+7 >           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+  >
+2 >var 
+3 >    a
+4 >      = 
+5 >        10
+6 >          ;
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0)
+3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0)
+4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0)
+5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0)
+6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=local/optionsSourcemapInlineSourcesMapRoot.js.map

tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.symbols

@@ -0,0 +1,5 @@
+=== tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.ts ===
+
+var a = 10;
+>a : Symbol(a, Decl(optionsSourcemapInlineSourcesMapRoot.ts, 1, 3))
+

tests/baselines/reference/optionsSourcemapInlineSourcesMapRoot.types

@@ -0,0 +1,6 @@
+=== tests/cases/compiler/optionsSourcemapInlineSourcesMapRoot.ts ===
+
+var a = 10;
+>a : number
+>10 : number
+

tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.errors.txt

@@ -0,0 +1,7 @@
+error TS5053: Option 'sourceRoot' cannot be specified with option 'inlineSources'.
+
+
+!!! error TS5053: Option 'sourceRoot' cannot be specified with option 'inlineSources'.
+==== tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.ts (0 errors) ====
+    
+    var a = 10;

tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js

@@ -0,0 +1,7 @@
+//// [optionsSourcemapInlineSourcesSourceRoot.ts]
+
+var a = 10;
+
+//// [optionsSourcemapInlineSourcesSourceRoot.js]
+var a = 10;
+//# sourceMappingURL=optionsSourcemapInlineSourcesSourceRoot.js.map

tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.js.map

@@ -0,0 +1,2 @@
+//// [optionsSourcemapInlineSourcesSourceRoot.js.map]
+{"version":3,"file":"optionsSourcemapInlineSourcesSourceRoot.js","sourceRoot":"local/","sources":["optionsSourcemapInlineSourcesSourceRoot.ts"],"names":[],"mappings":"AACA,IAAI,CAAC,GAAG,EAAE,CAAC","sourcesContent":["\nvar a = 10;"]}

tests/baselines/reference/optionsSourcemapInlineSourcesSourceRoot.sourcemap.txt

@@ -0,0 +1,34 @@
+===================================================================
+JsFile: optionsSourcemapInlineSourcesSourceRoot.js
+mapUrl: optionsSourcemapInlineSourcesSourceRoot.js.map
+sourceRoot: local/
+sources: optionsSourcemapInlineSourcesSourceRoot.ts
+sourcesContent: ["\nvar a = 10;"]
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/optionsSourcemapInlineSourcesSourceRoot.js
+sourceFile:optionsSourcemapInlineSourcesSourceRoot.ts
+-------------------------------------------------------------------
+>>>var a = 10;
+1 >
+2 >^^^^
+3 >    ^
+4 >     ^^^
+5 >        ^^
+6 >          ^
+7 >           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+  >
+2 >var 
+3 >    a
+4 >      = 
+5 >        10
+6 >          ;
+1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0)
+2 >Emitted(1, 5) Source(2, 5) + SourceIndex(0)
+3 >Emitted(1, 6) Source(2, 6) + SourceIndex(0)
+4 >Emitted(1, 9) Source(2, 9) + SourceIndex(0)
+5 >Emitted(1, 11) Source(2, 11) + SourceIndex(0)
+6 >Emitted(1, 12) Source(2, 12) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=optionsSourcemapInlineSourcesSourceRoot.js.map

tests/baselines/reference/sourceMapValidationLambdaSpanningMultipleLines.js

@@ -0,0 +1,10 @@
+//// [sourceMapValidationLambdaSpanningMultipleLines.ts]
+((item: string) =>
+    item
+)
+
+//// [sourceMapValidationLambdaSpanningMultipleLines.js]
+(function (item) {
+    return item;
+});
+//# sourceMappingURL=sourceMapValidationLambdaSpanningMultipleLines.js.map

tests/baselines/reference/sourceMapValidationLambdaSpanningMultipleLines.js.map

@@ -0,0 +1,2 @@
+//// [sourceMapValidationLambdaSpanningMultipleLines.js.map]
+{"version":3,"file":"sourceMapValidationLambdaSpanningMultipleLines.js","sourceRoot":"","sources":["sourceMapValidationLambdaSpanningMultipleLines.ts"],"names":[],"mappings":"AAAA,CAAC,UAAC,IAAY;IACV,OAAA,IAAI;AAAJ,CAAI,CACP,CAAA"}

tests/baselines/reference/sourceMapValidationLambdaSpanningMultipleLines.sourcemap.txt

@@ -0,0 +1,54 @@
+===================================================================
+JsFile: sourceMapValidationLambdaSpanningMultipleLines.js
+mapUrl: sourceMapValidationLambdaSpanningMultipleLines.js.map
+sourceRoot: 
+sources: sourceMapValidationLambdaSpanningMultipleLines.ts
+===================================================================
+-------------------------------------------------------------------
+emittedFile:tests/cases/compiler/sourceMapValidationLambdaSpanningMultipleLines.js
+sourceFile:sourceMapValidationLambdaSpanningMultipleLines.ts
+-------------------------------------------------------------------
+>>>(function (item) {
+1 >
+2 >^
+3 > ^^^^^^^^^^
+4 >           ^^^^
+5 >               ^^->
+1 >
+2 >(
+3 > (
+4 >           item: string
+1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0)
+2 >Emitted(1, 2) Source(1, 2) + SourceIndex(0)
+3 >Emitted(1, 12) Source(1, 3) + SourceIndex(0)
+4 >Emitted(1, 16) Source(1, 15) + SourceIndex(0)
+---
+>>>    return item;
+1->^^^^
+2 >    ^^^^^^^
+3 >           ^^^^
+1->) =>
+  >    
+2 >    
+3 >           item
+1->Emitted(2, 5) Source(2, 5) + SourceIndex(0)
+2 >Emitted(2, 12) Source(2, 5) + SourceIndex(0)
+3 >Emitted(2, 16) Source(2, 9) + SourceIndex(0)
+---
+>>>});
+1 >
+2 >^
+3 > ^
+4 >  ^
+5 >   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
+1 >
+2 >item
+3 > 
+  > )
+4 >  
+1 >Emitted(3, 1) Source(2, 5) + SourceIndex(0)
+2 >Emitted(3, 2) Source(2, 9) + SourceIndex(0)
+3 >Emitted(3, 3) Source(3, 2) + SourceIndex(0)
+4 >Emitted(3, 4) Source(3, 2) + SourceIndex(0)
+---
+>>>//# sourceMappingURL=sourceMapValidationLambdaSpanningMultipleLines.js.map

tests/baselines/reference/sourceMapValidationLambdaSpanningMultipleLines.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/sourceMapValidationLambdaSpanningMultipleLines.ts ===
+((item: string) =>
+>item : Symbol(item, Decl(sourceMapValidationLambdaSpanningMultipleLines.ts, 0, 2))
+
+    item
+>item : Symbol(item, Decl(sourceMapValidationLambdaSpanningMultipleLines.ts, 0, 2))
+
+)

tests/baselines/reference/sourceMapValidationLambdaSpanningMultipleLines.types

@@ -0,0 +1,10 @@
+=== tests/cases/compiler/sourceMapValidationLambdaSpanningMultipleLines.ts ===
+((item: string) =>
+>((item: string) =>    item) : (item: string) => string
+>(item: string) =>    item : (item: string) => string
+>item : string
+
+    item
+>item : string
+
+)

tests/baselines/reference/symbolType18.types

@@ -21,5 +21,5 @@ if (typeof x === "object") {
 }
 else {
     x;
->x : symbol | Foo
+>x : symbol
 }

tests/baselines/reference/tsxExternalModuleEmit2.js

@@ -20,6 +20,6 @@ declare var Foo, React;
 //// [app.js]
 var mod_1 = require('mod');
 // Should see mod_1['default'] in emit here
-React.createElement(Foo, {"handler": mod_1["default"]});
+React.createElement(Foo, {handler: mod_1["default"]});
 // Should see mod_1['default'] in emit here
 React.createElement(Foo, React.__spread({}, mod_1["default"]));

tests/baselines/reference/tsxReactEmit7.errors.txt

@@ -0,0 +1,50 @@
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(9,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(10,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(11,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(12,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(15,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(16,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(17,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(18,10): error TS2304: Cannot find name 'React'.
+tests/cases/conformance/jsx/tsxReactEmit7.tsx(19,10): error TS2304: Cannot find name 'React'.
+
+
+==== tests/cases/conformance/jsx/tsxReactEmit7.tsx (9 errors) ====
+    
+    declare module JSX {
+    	interface Element { }
+    	interface IntrinsicElements {
+    		[s: string]: any;
+    	}
+    }
+    
+    var m = <div x-y="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var n = <div xx-y="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var o = <div x-yy="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var p = <div xx-yy="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    
+    // Investigation
+    var a = <div x="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var b = <div xx="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var c = <div xxx="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var d = <div xxxx="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    var e = <div xxxxx="val"></div>;
+             ~~~
+!!! error TS2304: Cannot find name 'React'.
+    

tests/baselines/reference/tsxReactEmit7.js

@@ -0,0 +1,33 @@
+//// [tsxReactEmit7.tsx]
+
+declare module JSX {
+	interface Element { }
+	interface IntrinsicElements {
+		[s: string]: any;
+	}
+}
+
+var m = <div x-y="val"></div>;
+var n = <div xx-y="val"></div>;
+var o = <div x-yy="val"></div>;
+var p = <div xx-yy="val"></div>;
+
+// Investigation
+var a = <div x="val"></div>;
+var b = <div xx="val"></div>;
+var c = <div xxx="val"></div>;
+var d = <div xxxx="val"></div>;
+var e = <div xxxxx="val"></div>;
+
+
+//// [tsxReactEmit7.js]
+var m = React.createElement("div", {"x-y": "val"});
+var n = React.createElement("div", {"xx-y": "val"});
+var o = React.createElement("div", {"x-yy": "val"});
+var p = React.createElement("div", {"xx-yy": "val"});
+// Investigation
+var a = React.createElement("div", {x: "val"});
+var b = React.createElement("div", {xx: "val"});
+var c = React.createElement("div", {xxx: "val"});
+var d = React.createElement("div", {xxxx: "val"});
+var e = React.createElement("div", {xxxxx: "val"});

tests/baselines/reference/typeGuardEnums.js

@@ -0,0 +1,41 @@
+//// [typeGuardEnums.ts]
+enum E {}
+enum V {}
+
+let x: number|string|E|V;
+
+if (typeof x === "number") {
+    x; // number|E|V
+}
+else {
+    x; // string
+}
+
+if (typeof x !== "number") {
+    x; // string
+}
+else {
+    x; // number|E|V
+}
+
+
+//// [typeGuardEnums.js]
+var E;
+(function (E) {
+})(E || (E = {}));
+var V;
+(function (V) {
+})(V || (V = {}));
+var x;
+if (typeof x === "number") {
+    x; // number|E|V
+}
+else {
+    x; // string
+}
+if (typeof x !== "number") {
+    x; // string
+}
+else {
+    x; // number|E|V
+}

tests/baselines/reference/typeGuardEnums.symbols

@@ -0,0 +1,34 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardEnums.ts ===
+enum E {}
+>E : Symbol(E, Decl(typeGuardEnums.ts, 0, 0))
+
+enum V {}
+>V : Symbol(V, Decl(typeGuardEnums.ts, 0, 9))
+
+let x: number|string|E|V;
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+>E : Symbol(E, Decl(typeGuardEnums.ts, 0, 0))
+>V : Symbol(V, Decl(typeGuardEnums.ts, 0, 9))
+
+if (typeof x === "number") {
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+
+    x; // number|E|V
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+}
+else {
+    x; // string
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+}
+
+if (typeof x !== "number") {
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+
+    x; // string
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+}
+else {
+    x; // number|E|V
+>x : Symbol(x, Decl(typeGuardEnums.ts, 3, 3))
+}
+

tests/baselines/reference/typeGuardEnums.types

@@ -0,0 +1,40 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardEnums.ts ===
+enum E {}
+>E : E
+
+enum V {}
+>V : V
+
+let x: number|string|E|V;
+>x : number | string | E | V
+>E : E
+>V : V
+
+if (typeof x === "number") {
+>typeof x === "number" : boolean
+>typeof x : string
+>x : number | string | E | V
+>"number" : string
+
+    x; // number|E|V
+>x : number | E | V
+}
+else {
+    x; // string
+>x : string
+}
+
+if (typeof x !== "number") {
+>typeof x !== "number" : boolean
+>typeof x : string
+>x : number | string | E | V
+>"number" : string
+
+    x; // string
+>x : string
+}
+else {
+    x; // number|E|V
+>x : number | E | V
+}
+

tests/baselines/reference/typeGuardNesting.js

@@ -0,0 +1,31 @@
+//// [typeGuardNesting.ts]
+let strOrBool: string|boolean;
+if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'string') {
+	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
+	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
+	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+	let bool2: boolean = (typeof strOrBool !== 'string') ? strOrBool : false;
+}
+
+if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boolean') {
+	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
+	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
+	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+	let bool2: boolean = (typeof strOrBool !== 'string') ? strOrBool : false;
+}
+
+
+//// [typeGuardNesting.js]
+var strOrBool;
+if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'string') {
+    var label = (typeof strOrBool === 'string') ? strOrBool : "string";
+    var bool = (typeof strOrBool === 'boolean') ? strOrBool : false;
+    var label2 = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+    var bool2 = (typeof strOrBool !== 'string') ? strOrBool : false;
+}
+if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boolean') {
+    var label = (typeof strOrBool === 'string') ? strOrBool : "string";
+    var bool = (typeof strOrBool === 'boolean') ? strOrBool : false;
+    var label2 = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+    var bool2 = (typeof strOrBool !== 'string') ? strOrBool : false;
+}

tests/baselines/reference/typeGuardNesting.symbols

@@ -0,0 +1,56 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardNesting.ts ===
+let strOrBool: string|boolean;
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'string') {
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
+>label : Symbol(label, Decl(typeGuardNesting.ts, 2, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
+>bool : Symbol(bool, Decl(typeGuardNesting.ts, 3, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+>label2 : Symbol(label2, Decl(typeGuardNesting.ts, 4, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let bool2: boolean = (typeof strOrBool !== 'string') ? strOrBool : false;
+>bool2 : Symbol(bool2, Decl(typeGuardNesting.ts, 5, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+}
+
+if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boolean') {
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
+>label : Symbol(label, Decl(typeGuardNesting.ts, 9, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
+>bool : Symbol(bool, Decl(typeGuardNesting.ts, 10, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+>label2 : Symbol(label2, Decl(typeGuardNesting.ts, 11, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+
+	let bool2: boolean = (typeof strOrBool !== 'string') ? strOrBool : false;
+>bool2 : Symbol(bool2, Decl(typeGuardNesting.ts, 12, 4))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+>strOrBool : Symbol(strOrBool, Decl(typeGuardNesting.ts, 0, 3))
+}
+

tests/baselines/reference/typeGuardNesting.types

@@ -0,0 +1,124 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardNesting.ts ===
+let strOrBool: string|boolean;
+>strOrBool : string | boolean
+
+if ((typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'string') {
+>(typeof strOrBool === 'boolean' && !strOrBool) || typeof strOrBool === 'string' : boolean
+>(typeof strOrBool === 'boolean' && !strOrBool) : boolean
+>typeof strOrBool === 'boolean' && !strOrBool : boolean
+>typeof strOrBool === 'boolean' : boolean
+>typeof strOrBool : string
+>strOrBool : string | boolean
+>'boolean' : string
+>!strOrBool : boolean
+>strOrBool : boolean
+>typeof strOrBool === 'string' : boolean
+>typeof strOrBool : string
+>strOrBool : string | boolean
+>'string' : string
+
+	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
+>label : string
+>(typeof strOrBool === 'string') ? strOrBool : "string" : string
+>(typeof strOrBool === 'string') : boolean
+>typeof strOrBool === 'string' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'string' : string
+>strOrBool : string
+>"string" : string
+
+	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
+>bool : boolean
+>(typeof strOrBool === 'boolean') ? strOrBool : false : boolean
+>(typeof strOrBool === 'boolean') : boolean
+>typeof strOrBool === 'boolean' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'boolean' : string
+>strOrBool : boolean
+>false : boolean
+
+	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+>label2 : string
+>(typeof strOrBool !== 'boolean') ? strOrBool : "string" : string
+>(typeof strOrBool !== 'boolean') : boolean
+>typeof strOrBool !== 'boolean' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'boolean' : string
+>strOrBool : string
+>"string" : string
+
+	let bool2: boolean = (typeof strOrBool !== 'string') ? strOrBool : false;
+>bool2 : boolean
+>(typeof strOrBool !== 'string') ? strOrBool : false : boolean
+>(typeof strOrBool !== 'string') : boolean
+>typeof strOrBool !== 'string' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'string' : string
+>strOrBool : boolean
+>false : boolean
+}
+
+if ((typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boolean') {
+>(typeof strOrBool !== 'string' && !strOrBool) || typeof strOrBool !== 'boolean' : boolean
+>(typeof strOrBool !== 'string' && !strOrBool) : boolean
+>typeof strOrBool !== 'string' && !strOrBool : boolean
+>typeof strOrBool !== 'string' : boolean
+>typeof strOrBool : string
+>strOrBool : string | boolean
+>'string' : string
+>!strOrBool : boolean
+>strOrBool : boolean
+>typeof strOrBool !== 'boolean' : boolean
+>typeof strOrBool : string
+>strOrBool : string | boolean
+>'boolean' : string
+
+	let label: string = (typeof strOrBool === 'string') ? strOrBool : "string";
+>label : string
+>(typeof strOrBool === 'string') ? strOrBool : "string" : string
+>(typeof strOrBool === 'string') : boolean
+>typeof strOrBool === 'string' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'string' : string
+>strOrBool : string
+>"string" : string
+
+	let bool: boolean = (typeof strOrBool === 'boolean') ? strOrBool : false;
+>bool : boolean
+>(typeof strOrBool === 'boolean') ? strOrBool : false : boolean
+>(typeof strOrBool === 'boolean') : boolean
+>typeof strOrBool === 'boolean' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'boolean' : string
+>strOrBool : boolean
+>false : boolean
+
+	let label2: string = (typeof strOrBool !== 'boolean') ? strOrBool : "string";
+>label2 : string
+>(typeof strOrBool !== 'boolean') ? strOrBool : "string" : string
+>(typeof strOrBool !== 'boolean') : boolean
+>typeof strOrBool !== 'boolean' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'boolean' : string
+>strOrBool : string
+>"string" : string
+
+	let bool2: boolean = (typeof strOrBool !== 'string') ? strOrBool : false;
+>bool2 : boolean
+>(typeof strOrBool !== 'string') ? strOrBool : false : boolean
+>(typeof strOrBool !== 'string') : boolean
+>typeof strOrBool !== 'string' : boolean
+>typeof strOrBool : string
+>strOrBool : boolean | string
+>'string' : string
+>strOrBool : boolean
+>false : boolean
+}
+

tests/baselines/reference/typeGuardOfFormTypeOfOther.js

@@ -23,19 +23,19 @@ if (typeof strOrC === "Object") {
     c = strOrC; // C
 }
 else {
-    var r2: string | C = strOrC; // string | C
+    var r2: string = strOrC; // string
 }
 if (typeof numOrC === "Object") {
     c = numOrC; // C
 }
 else {
-    var r3: number | C = numOrC; // number | C
+    var r3: number  = numOrC; // number
 }
 if (typeof boolOrC === "Object") {
     c = boolOrC; // C
 }
 else {
-    var r4: boolean | C = boolOrC; // boolean | C
+    var r4: boolean = boolOrC; // boolean
 }
 
 // Narrowing occurs only if target type is a subtype of variable type
@@ -50,19 +50,19 @@ else {
 //  - when true, narrows the type of x by typeof x === s when false, or
 //  - when false, narrows the type of x by typeof x === s when true.
 if (typeof strOrC !== "Object") {
-    var r2: string | C = strOrC; // string | C
+    var r2: string = strOrC; // string
 }
 else {
     c = strOrC; // C
 }
 if (typeof numOrC !== "Object") {
-    var r3: number | C = numOrC; // number | C
+    var r3: number = numOrC; // number
 }
 else {
     c = numOrC; // C
 }
 if (typeof boolOrC !== "Object") {
-    var r4: boolean | C = boolOrC; // boolean | C
+    var r4: boolean = boolOrC; // boolean
 }
 else {
     c = boolOrC; // C
@@ -104,19 +104,19 @@ if (typeof strOrC === "Object") {
     c = strOrC; // C
 }
 else {
-    var r2 = strOrC; // string | C
+    var r2 = strOrC; // string
 }
 if (typeof numOrC === "Object") {
     c = numOrC; // C
 }
 else {
-    var r3 = numOrC; // number | C
+    var r3 = numOrC; // number
 }
 if (typeof boolOrC === "Object") {
     c = boolOrC; // C
 }
 else {
-    var r4 = boolOrC; // boolean | C
+    var r4 = boolOrC; // boolean
 }
 // Narrowing occurs only if target type is a subtype of variable type
 if (typeof strOrNumOrBool === "Object") {
@@ -129,19 +129,19 @@ else {
 //  - when true, narrows the type of x by typeof x === s when false, or
 //  - when false, narrows the type of x by typeof x === s when true.
 if (typeof strOrC !== "Object") {
-    var r2 = strOrC; // string | C
+    var r2 = strOrC; // string
 }
 else {
     c = strOrC; // C
 }
 if (typeof numOrC !== "Object") {
-    var r3 = numOrC; // number | C
+    var r3 = numOrC; // number
 }
 else {
     c = numOrC; // C
 }
 if (typeof boolOrC !== "Object") {
-    var r4 = boolOrC; // boolean | C
+    var r4 = boolOrC; // boolean
 }
 else {
     c = boolOrC; // C

tests/baselines/reference/typeGuardOfFormTypeOfOther.symbols

@@ -56,9 +56,8 @@ if (typeof strOrC === "Object") {
 >strOrC : Symbol(strOrC, Decl(typeGuardOfFormTypeOfOther.ts, 9, 3))
 }
 else {
-    var r2: string | C = strOrC; // string | C
+    var r2: string = strOrC; // string
 >r2 : Symbol(r2, Decl(typeGuardOfFormTypeOfOther.ts, 24, 7), Decl(typeGuardOfFormTypeOfOther.ts, 51, 7))
->C : Symbol(C, Decl(typeGuardOfFormTypeOfOther.ts, 0, 0))
 >strOrC : Symbol(strOrC, Decl(typeGuardOfFormTypeOfOther.ts, 9, 3))
 }
 if (typeof numOrC === "Object") {
@@ -69,9 +68,8 @@ if (typeof numOrC === "Object") {
 >numOrC : Symbol(numOrC, Decl(typeGuardOfFormTypeOfOther.ts, 10, 3))
 }
 else {
-    var r3: number | C = numOrC; // number | C
+    var r3: number  = numOrC; // number
 >r3 : Symbol(r3, Decl(typeGuardOfFormTypeOfOther.ts, 30, 7), Decl(typeGuardOfFormTypeOfOther.ts, 57, 7))
->C : Symbol(C, Decl(typeGuardOfFormTypeOfOther.ts, 0, 0))
 >numOrC : Symbol(numOrC, Decl(typeGuardOfFormTypeOfOther.ts, 10, 3))
 }
 if (typeof boolOrC === "Object") {
@@ -82,9 +80,8 @@ if (typeof boolOrC === "Object") {
 >boolOrC : Symbol(boolOrC, Decl(typeGuardOfFormTypeOfOther.ts, 11, 3))
 }
 else {
-    var r4: boolean | C = boolOrC; // boolean | C
+    var r4: boolean = boolOrC; // boolean
 >r4 : Symbol(r4, Decl(typeGuardOfFormTypeOfOther.ts, 36, 7), Decl(typeGuardOfFormTypeOfOther.ts, 63, 7))
->C : Symbol(C, Decl(typeGuardOfFormTypeOfOther.ts, 0, 0))
 >boolOrC : Symbol(boolOrC, Decl(typeGuardOfFormTypeOfOther.ts, 11, 3))
 }
 
@@ -108,9 +105,8 @@ else {
 if (typeof strOrC !== "Object") {
 >strOrC : Symbol(strOrC, Decl(typeGuardOfFormTypeOfOther.ts, 9, 3))
 
-    var r2: string | C = strOrC; // string | C
+    var r2: string = strOrC; // string
 >r2 : Symbol(r2, Decl(typeGuardOfFormTypeOfOther.ts, 24, 7), Decl(typeGuardOfFormTypeOfOther.ts, 51, 7))
->C : Symbol(C, Decl(typeGuardOfFormTypeOfOther.ts, 0, 0))
 >strOrC : Symbol(strOrC, Decl(typeGuardOfFormTypeOfOther.ts, 9, 3))
 }
 else {
@@ -121,9 +117,8 @@ else {
 if (typeof numOrC !== "Object") {
 >numOrC : Symbol(numOrC, Decl(typeGuardOfFormTypeOfOther.ts, 10, 3))
 
-    var r3: number | C = numOrC; // number | C
+    var r3: number = numOrC; // number
 >r3 : Symbol(r3, Decl(typeGuardOfFormTypeOfOther.ts, 30, 7), Decl(typeGuardOfFormTypeOfOther.ts, 57, 7))
->C : Symbol(C, Decl(typeGuardOfFormTypeOfOther.ts, 0, 0))
 >numOrC : Symbol(numOrC, Decl(typeGuardOfFormTypeOfOther.ts, 10, 3))
 }
 else {
@@ -134,9 +129,8 @@ else {
 if (typeof boolOrC !== "Object") {
 >boolOrC : Symbol(boolOrC, Decl(typeGuardOfFormTypeOfOther.ts, 11, 3))
 
-    var r4: boolean | C = boolOrC; // boolean | C
+    var r4: boolean = boolOrC; // boolean
 >r4 : Symbol(r4, Decl(typeGuardOfFormTypeOfOther.ts, 36, 7), Decl(typeGuardOfFormTypeOfOther.ts, 63, 7))
->C : Symbol(C, Decl(typeGuardOfFormTypeOfOther.ts, 0, 0))
 >boolOrC : Symbol(boolOrC, Decl(typeGuardOfFormTypeOfOther.ts, 11, 3))
 }
 else {

tests/baselines/reference/typeGuardOfFormTypeOfOther.types

@@ -60,10 +60,9 @@ if (typeof strOrC === "Object") {
 >strOrC : C
 }
 else {
-    var r2: string | C = strOrC; // string | C
->r2 : string | C
->C : C
->strOrC : string | C
+    var r2: string = strOrC; // string
+>r2 : string
+>strOrC : string
 }
 if (typeof numOrC === "Object") {
 >typeof numOrC === "Object" : boolean
@@ -77,10 +76,9 @@ if (typeof numOrC === "Object") {
 >numOrC : C
 }
 else {
-    var r3: number | C = numOrC; // number | C
->r3 : number | C
->C : C
->numOrC : number | C
+    var r3: number  = numOrC; // number
+>r3 : number
+>numOrC : number
 }
 if (typeof boolOrC === "Object") {
 >typeof boolOrC === "Object" : boolean
@@ -94,10 +92,9 @@ if (typeof boolOrC === "Object") {
 >boolOrC : C
 }
 else {
-    var r4: boolean | C = boolOrC; // boolean | C
->r4 : boolean | C
->C : C
->boolOrC : boolean | C
+    var r4: boolean = boolOrC; // boolean
+>r4 : boolean
+>boolOrC : boolean
 }
 
 // Narrowing occurs only if target type is a subtype of variable type
@@ -126,10 +123,9 @@ if (typeof strOrC !== "Object") {
 >strOrC : string | C
 >"Object" : string
 
-    var r2: string | C = strOrC; // string | C
->r2 : string | C
->C : C
->strOrC : string | C
+    var r2: string = strOrC; // string
+>r2 : string
+>strOrC : string
 }
 else {
     c = strOrC; // C
@@ -143,10 +139,9 @@ if (typeof numOrC !== "Object") {
 >numOrC : number | C
 >"Object" : string
 
-    var r3: number | C = numOrC; // number | C
->r3 : number | C
->C : C
->numOrC : number | C
+    var r3: number = numOrC; // number
+>r3 : number
+>numOrC : number
 }
 else {
     c = numOrC; // C
@@ -160,10 +155,9 @@ if (typeof boolOrC !== "Object") {
 >boolOrC : boolean | C
 >"Object" : string
 
-    var r4: boolean | C = boolOrC; // boolean | C
->r4 : boolean | C
->C : C
->boolOrC : boolean | C
+    var r4: boolean = boolOrC; // boolean
+>r4 : boolean
+>boolOrC : boolean
 }
 else {
     c = boolOrC; // C

tests/baselines/reference/typeGuardRedundancy.js

@@ -0,0 +1,17 @@
+//// [typeGuardRedundancy.ts]
+var x: string|number;
+
+var r1 = typeof x === "string" && typeof x === "string" ? x.substr : x.toFixed;
+
+var r2 = !(typeof x === "string" && typeof x === "string") ? x.toFixed : x.substr;
+
+var r3 = typeof x === "string" || typeof x === "string" ? x.substr : x.toFixed;
+
+var r4 = !(typeof x === "string" || typeof x === "string") ? x.toFixed : x.substr;
+
+//// [typeGuardRedundancy.js]
+var x;
+var r1 = typeof x === "string" && typeof x === "string" ? x.substr : x.toFixed;
+var r2 = !(typeof x === "string" && typeof x === "string") ? x.toFixed : x.substr;
+var r3 = typeof x === "string" || typeof x === "string" ? x.substr : x.toFixed;
+var r4 = !(typeof x === "string" || typeof x === "string") ? x.toFixed : x.substr;

tests/baselines/reference/typeGuardRedundancy.symbols

@@ -0,0 +1,48 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardRedundancy.ts ===
+var x: string|number;
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+
+var r1 = typeof x === "string" && typeof x === "string" ? x.substr : x.toFixed;
+>r1 : Symbol(r1, Decl(typeGuardRedundancy.ts, 2, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x.substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+
+var r2 = !(typeof x === "string" && typeof x === "string") ? x.toFixed : x.substr;
+>r2 : Symbol(r2, Decl(typeGuardRedundancy.ts, 4, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+>x.substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+
+var r3 = typeof x === "string" || typeof x === "string" ? x.substr : x.toFixed;
+>r3 : Symbol(r3, Decl(typeGuardRedundancy.ts, 6, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x.substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+
+var r4 = !(typeof x === "string" || typeof x === "string") ? x.toFixed : x.substr;
+>r4 : Symbol(r4, Decl(typeGuardRedundancy.ts, 8, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --))
+>x.substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(typeGuardRedundancy.ts, 0, 3))
+>substr : Symbol(String.substr, Decl(lib.d.ts, --, --))
+

tests/baselines/reference/typeGuardRedundancy.types

@@ -0,0 +1,84 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardRedundancy.ts ===
+var x: string|number;
+>x : string | number
+
+var r1 = typeof x === "string" && typeof x === "string" ? x.substr : x.toFixed;
+>r1 : (from: number, length?: number) => string
+>typeof x === "string" && typeof x === "string" ? x.substr : x.toFixed : (from: number, length?: number) => string
+>typeof x === "string" && typeof x === "string" : boolean
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string
+>"string" : string
+>x.substr : (from: number, length?: number) => string
+>x : string
+>substr : (from: number, length?: number) => string
+>x.toFixed : (fractionDigits?: number) => string
+>x : number
+>toFixed : (fractionDigits?: number) => string
+
+var r2 = !(typeof x === "string" && typeof x === "string") ? x.toFixed : x.substr;
+>r2 : (fractionDigits?: number) => string
+>!(typeof x === "string" && typeof x === "string") ? x.toFixed : x.substr : (fractionDigits?: number) => string
+>!(typeof x === "string" && typeof x === "string") : boolean
+>(typeof x === "string" && typeof x === "string") : boolean
+>typeof x === "string" && typeof x === "string" : boolean
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string
+>"string" : string
+>x.toFixed : (fractionDigits?: number) => string
+>x : number
+>toFixed : (fractionDigits?: number) => string
+>x.substr : (from: number, length?: number) => string
+>x : string
+>substr : (from: number, length?: number) => string
+
+var r3 = typeof x === "string" || typeof x === "string" ? x.substr : x.toFixed;
+>r3 : (from: number, length?: number) => string
+>typeof x === "string" || typeof x === "string" ? x.substr : x.toFixed : (from: number, length?: number) => string
+>typeof x === "string" || typeof x === "string" : boolean
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+>typeof x === "string" : boolean
+>typeof x : string
+>x : number
+>"string" : string
+>x.substr : (from: number, length?: number) => string
+>x : string
+>substr : (from: number, length?: number) => string
+>x.toFixed : (fractionDigits?: number) => string
+>x : number
+>toFixed : (fractionDigits?: number) => string
+
+var r4 = !(typeof x === "string" || typeof x === "string") ? x.toFixed : x.substr;
+>r4 : (fractionDigits?: number) => string
+>!(typeof x === "string" || typeof x === "string") ? x.toFixed : x.substr : (fractionDigits?: number) => string
+>!(typeof x === "string" || typeof x === "string") : boolean
+>(typeof x === "string" || typeof x === "string") : boolean
+>typeof x === "string" || typeof x === "string" : boolean
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+>typeof x === "string" : boolean
+>typeof x : string
+>x : number
+>"string" : string
+>x.toFixed : (fractionDigits?: number) => string
+>x : number
+>toFixed : (fractionDigits?: number) => string
+>x.substr : (from: number, length?: number) => string
+>x : string
+>substr : (from: number, length?: number) => string
+

tests/baselines/reference/typeGuardTautologicalConsistiency.js

@@ -0,0 +1,24 @@
+//// [typeGuardTautologicalConsistiency.ts]
+let stringOrNumber: string | number;
+
+if (typeof stringOrNumber === "number") {
+    if (typeof stringOrNumber !== "number") {
+        stringOrNumber;
+    }
+}
+
+if (typeof stringOrNumber === "number" && typeof stringOrNumber !== "number") {
+    stringOrNumber;
+}
+
+
+//// [typeGuardTautologicalConsistiency.js]
+var stringOrNumber;
+if (typeof stringOrNumber === "number") {
+    if (typeof stringOrNumber !== "number") {
+        stringOrNumber;
+    }
+}
+if (typeof stringOrNumber === "number" && typeof stringOrNumber !== "number") {
+    stringOrNumber;
+}

tests/baselines/reference/typeGuardTautologicalConsistiency.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardTautologicalConsistiency.ts ===
+let stringOrNumber: string | number;
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+
+if (typeof stringOrNumber === "number") {
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+
+    if (typeof stringOrNumber !== "number") {
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+
+        stringOrNumber;
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+    }
+}
+
+if (typeof stringOrNumber === "number" && typeof stringOrNumber !== "number") {
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+
+    stringOrNumber;
+>stringOrNumber : Symbol(stringOrNumber, Decl(typeGuardTautologicalConsistiency.ts, 0, 3))
+}
+

tests/baselines/reference/typeGuardTautologicalConsistiency.types

@@ -0,0 +1,36 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardTautologicalConsistiency.ts ===
+let stringOrNumber: string | number;
+>stringOrNumber : string | number
+
+if (typeof stringOrNumber === "number") {
+>typeof stringOrNumber === "number" : boolean
+>typeof stringOrNumber : string
+>stringOrNumber : string | number
+>"number" : string
+
+    if (typeof stringOrNumber !== "number") {
+>typeof stringOrNumber !== "number" : boolean
+>typeof stringOrNumber : string
+>stringOrNumber : number
+>"number" : string
+
+        stringOrNumber;
+>stringOrNumber : string | number
+    }
+}
+
+if (typeof stringOrNumber === "number" && typeof stringOrNumber !== "number") {
+>typeof stringOrNumber === "number" && typeof stringOrNumber !== "number" : boolean
+>typeof stringOrNumber === "number" : boolean
+>typeof stringOrNumber : string
+>stringOrNumber : string | number
+>"number" : string
+>typeof stringOrNumber !== "number" : boolean
+>typeof stringOrNumber : string
+>stringOrNumber : number
+>"number" : string
+
+    stringOrNumber;
+>stringOrNumber : string | number
+}
+

tests/baselines/reference/typeGuardTypeOfUndefined.js

@@ -0,0 +1,357 @@
+//// [typeGuardTypeOfUndefined.ts]
+// undefined type guard adds no new type information
+function test1(a: any) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test2(a: any) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test3(a: any) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test4(a: any) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test5(a: boolean | void) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test6(a: boolean | void) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test7(a: boolean | void) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test8(a: boolean | void) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test9(a: boolean | number) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test10(a: boolean | number) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test11(a: boolean | number) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test12(a: boolean | number) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test13(a: boolean | number | void) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test14(a: boolean | number | void) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+
+function test15(a: boolean | number | void) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+function test16(a: boolean | number | void) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+		a;
+    }
+    else {
+        a;
+    }
+}
+
+
+//// [typeGuardTypeOfUndefined.js]
+// undefined type guard adds no new type information
+function test1(a) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test2(a) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test3(a) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test4(a) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test5(a) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test6(a) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test7(a) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test8(a) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test9(a) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test10(a) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test11(a) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test12(a) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test13(a) {
+    if (typeof a !== "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test14(a) {
+    if (typeof a === "undefined") {
+        if (typeof a === "boolean") {
+            a;
+        }
+        else {
+            a;
+        }
+    }
+    else {
+        a;
+    }
+}
+function test15(a) {
+    if (typeof a === "undefined" || typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}
+function test16(a) {
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+        a;
+    }
+    else {
+        a;
+    }
+}

tests/baselines/reference/typeGuardTypeOfUndefined.symbols

@@ -0,0 +1,330 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardTypeOfUndefined.ts ===
+// undefined type guard adds no new type information
+function test1(a: any) {
+>test1 : Symbol(test1, Decl(typeGuardTypeOfUndefined.ts, 0, 0))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 1, 15))
+
+    if (typeof a !== "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 1, 15))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 1, 15))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 1, 15))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 1, 15))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 1, 15))
+    }
+}
+
+function test2(a: any) {
+>test2 : Symbol(test2, Decl(typeGuardTypeOfUndefined.ts, 13, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 15, 15))
+
+    if (typeof a === "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 15, 15))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 15, 15))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 15, 15))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 15, 15))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 15, 15))
+    }
+}
+
+function test3(a: any) {
+>test3 : Symbol(test3, Decl(typeGuardTypeOfUndefined.ts, 27, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 29, 15))
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 29, 15))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 29, 15))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 29, 15))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 29, 15))
+    }
+}
+
+function test4(a: any) {
+>test4 : Symbol(test4, Decl(typeGuardTypeOfUndefined.ts, 36, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 38, 15))
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 38, 15))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 38, 15))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 38, 15))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 38, 15))
+    }
+}
+
+function test5(a: boolean | void) {
+>test5 : Symbol(test5, Decl(typeGuardTypeOfUndefined.ts, 45, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 47, 15))
+
+    if (typeof a !== "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 47, 15))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 47, 15))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 47, 15))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 47, 15))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 47, 15))
+    }
+}
+
+function test6(a: boolean | void) {
+>test6 : Symbol(test6, Decl(typeGuardTypeOfUndefined.ts, 59, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 61, 15))
+
+    if (typeof a === "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 61, 15))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 61, 15))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 61, 15))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 61, 15))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 61, 15))
+    }
+}
+
+function test7(a: boolean | void) {
+>test7 : Symbol(test7, Decl(typeGuardTypeOfUndefined.ts, 73, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 75, 15))
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 75, 15))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 75, 15))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 75, 15))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 75, 15))
+    }
+}
+
+function test8(a: boolean | void) {
+>test8 : Symbol(test8, Decl(typeGuardTypeOfUndefined.ts, 82, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 84, 15))
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 84, 15))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 84, 15))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 84, 15))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 84, 15))
+    }
+}
+
+function test9(a: boolean | number) {
+>test9 : Symbol(test9, Decl(typeGuardTypeOfUndefined.ts, 91, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 93, 15))
+
+    if (typeof a !== "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 93, 15))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 93, 15))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 93, 15))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 93, 15))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 93, 15))
+    }
+}
+
+function test10(a: boolean | number) {
+>test10 : Symbol(test10, Decl(typeGuardTypeOfUndefined.ts, 105, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 107, 16))
+
+    if (typeof a === "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 107, 16))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 107, 16))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 107, 16))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 107, 16))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 107, 16))
+    }
+}
+
+function test11(a: boolean | number) {
+>test11 : Symbol(test11, Decl(typeGuardTypeOfUndefined.ts, 119, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 121, 16))
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 121, 16))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 121, 16))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 121, 16))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 121, 16))
+    }
+}
+
+function test12(a: boolean | number) {
+>test12 : Symbol(test12, Decl(typeGuardTypeOfUndefined.ts, 128, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 130, 16))
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 130, 16))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 130, 16))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 130, 16))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 130, 16))
+    }
+}
+
+function test13(a: boolean | number | void) {
+>test13 : Symbol(test13, Decl(typeGuardTypeOfUndefined.ts, 137, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 139, 16))
+
+    if (typeof a !== "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 139, 16))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 139, 16))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 139, 16))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 139, 16))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 139, 16))
+    }
+}
+
+function test14(a: boolean | number | void) {
+>test14 : Symbol(test14, Decl(typeGuardTypeOfUndefined.ts, 151, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 153, 16))
+
+    if (typeof a === "undefined") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 153, 16))
+
+        if (typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 153, 16))
+
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 153, 16))
+        }
+        else {
+            a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 153, 16))
+        }
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 153, 16))
+    }
+}
+
+function test15(a: boolean | number | void) {
+>test15 : Symbol(test15, Decl(typeGuardTypeOfUndefined.ts, 165, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 167, 16))
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 167, 16))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 167, 16))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 167, 16))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 167, 16))
+    }
+}
+
+function test16(a: boolean | number | void) {
+>test16 : Symbol(test16, Decl(typeGuardTypeOfUndefined.ts, 174, 1))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 176, 16))
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 176, 16))
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 176, 16))
+
+		a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 176, 16))
+    }
+    else {
+        a;
+>a : Symbol(a, Decl(typeGuardTypeOfUndefined.ts, 176, 16))
+    }
+}
+

tests/baselines/reference/typeGuardTypeOfUndefined.types

@@ -0,0 +1,434 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardTypeOfUndefined.ts ===
+// undefined type guard adds no new type information
+function test1(a: any) {
+>test1 : (a: any) => void
+>a : any
+
+    if (typeof a !== "undefined") {
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : any
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : any
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : any
+        }
+    }
+    else {
+        a;
+>a : any
+    }
+}
+
+function test2(a: any) {
+>test2 : (a: any) => void
+>a : any
+
+    if (typeof a === "undefined") {
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : any
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : any
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : any
+        }
+    }
+    else {
+        a;
+>a : any
+    }
+}
+
+function test3(a: any) {
+>test3 : (a: any) => void
+>a : any
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>typeof a === "undefined" || typeof a === "boolean" : boolean
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : any
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : any
+>"boolean" : string
+
+		a;
+>a : any
+    }
+    else {
+        a;
+>a : any
+    }
+}
+
+function test4(a: any) {
+>test4 : (a: any) => void
+>a : any
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>typeof a !== "undefined" && typeof a === "boolean" : boolean
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : any
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : any
+>"boolean" : string
+
+		a;
+>a : boolean
+    }
+    else {
+        a;
+>a : any
+    }
+}
+
+function test5(a: boolean | void) {
+>test5 : (a: boolean | void) => void
+>a : boolean | void
+
+    if (typeof a !== "undefined") {
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : boolean | void
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | void
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : void
+        }
+    }
+    else {
+        a;
+>a : boolean | void
+    }
+}
+
+function test6(a: boolean | void) {
+>test6 : (a: boolean | void) => void
+>a : boolean | void
+
+    if (typeof a === "undefined") {
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : boolean | void
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | void
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : void
+        }
+    }
+    else {
+        a;
+>a : boolean | void
+    }
+}
+
+function test7(a: boolean | void) {
+>test7 : (a: boolean | void) => void
+>a : boolean | void
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>typeof a === "undefined" || typeof a === "boolean" : boolean
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : boolean | void
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | void
+>"boolean" : string
+
+		a;
+>a : boolean | void
+    }
+    else {
+        a;
+>a : void
+    }
+}
+
+function test8(a: boolean | void) {
+>test8 : (a: boolean | void) => void
+>a : boolean | void
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>typeof a !== "undefined" && typeof a === "boolean" : boolean
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : boolean | void
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | void
+>"boolean" : string
+
+		a;
+>a : boolean
+    }
+    else {
+        a;
+>a : boolean | void
+    }
+}
+
+function test9(a: boolean | number) {
+>test9 : (a: boolean | number) => void
+>a : boolean | number
+
+    if (typeof a !== "undefined") {
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : boolean | number
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : number
+        }
+    }
+    else {
+        a;
+>a : boolean | number
+    }
+}
+
+function test10(a: boolean | number) {
+>test10 : (a: boolean | number) => void
+>a : boolean | number
+
+    if (typeof a === "undefined") {
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : boolean | number
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : number
+        }
+    }
+    else {
+        a;
+>a : boolean | number
+    }
+}
+
+function test11(a: boolean | number) {
+>test11 : (a: boolean | number) => void
+>a : boolean | number
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>typeof a === "undefined" || typeof a === "boolean" : boolean
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : boolean | number
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number
+>"boolean" : string
+
+		a;
+>a : boolean | number
+    }
+    else {
+        a;
+>a : number
+    }
+}
+
+function test12(a: boolean | number) {
+>test12 : (a: boolean | number) => void
+>a : boolean | number
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>typeof a !== "undefined" && typeof a === "boolean" : boolean
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : boolean | number
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number
+>"boolean" : string
+
+		a;
+>a : boolean
+    }
+    else {
+        a;
+>a : boolean | number
+    }
+}
+
+function test13(a: boolean | number | void) {
+>test13 : (a: boolean | number | void) => void
+>a : boolean | number | void
+
+    if (typeof a !== "undefined") {
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : number | void
+        }
+    }
+    else {
+        a;
+>a : boolean | number | void
+    }
+}
+
+function test14(a: boolean | number | void) {
+>test14 : (a: boolean | number | void) => void
+>a : boolean | number | void
+
+    if (typeof a === "undefined") {
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"undefined" : string
+
+        if (typeof a === "boolean") {
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"boolean" : string
+
+            a;
+>a : boolean
+        }
+        else {
+            a;
+>a : number | void
+        }
+    }
+    else {
+        a;
+>a : boolean | number | void
+    }
+}
+
+function test15(a: boolean | number | void) {
+>test15 : (a: boolean | number | void) => void
+>a : boolean | number | void
+
+    if (typeof a === "undefined" || typeof a === "boolean") {
+>typeof a === "undefined" || typeof a === "boolean" : boolean
+>typeof a === "undefined" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"boolean" : string
+
+		a;
+>a : boolean | number | void
+    }
+    else {
+        a;
+>a : number | void
+    }
+}
+
+function test16(a: boolean | number | void) {
+>test16 : (a: boolean | number | void) => void
+>a : boolean | number | void
+
+    if (typeof a !== "undefined" && typeof a === "boolean") {
+>typeof a !== "undefined" && typeof a === "boolean" : boolean
+>typeof a !== "undefined" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"undefined" : string
+>typeof a === "boolean" : boolean
+>typeof a : string
+>a : boolean | number | void
+>"boolean" : string
+
+		a;
+>a : boolean
+    }
+    else {
+        a;
+>a : boolean | number | void
+    }
+}
+

tests/cases/compiler/ambientClassDeclarationWithExtends.ts

@@ -1,2 +1,23 @@
+// @Filename: ambientClassDeclarationExtends_singleFile.ts
 declare class A { }
 declare class B extends A { }
+
+declare class C {
+    public foo;
+}
+namespace D { var x; }
+declare class D extends C { }
+
+var d: C = new D();
+
+// @Filename: ambientClassDeclarationExtends_file1.ts
+
+declare class E {
+    public bar;
+}
+namespace F { var y; }
+
+// @Filename: ambientClassDeclarationExtends_file2.ts
+
+declare class F extends E { }
+var f: E = new F();

tests/cases/compiler/checkSwitchStatementIfCaseTypeIsString.ts

@@ -0,0 +1,11 @@
+declare function use(a: any): void;
+
+class A {
+    doIt(x: Array<string>): void {
+        x.forEach((v) => {
+            switch(v) {
+                case "test": use(this);
+            }
+        });
+    }
+}

tests/cases/compiler/mixedStaticAndInstanceClassMembers.ts

@@ -0,0 +1,15 @@
+class A {
+    f() {}
+    static m1 (a: string): void;
+    m1 (a: number): void;
+    m1 (a: any): void {
+    }
+}
+
+class B {
+    f() {}
+    m1 (a: string): void;
+    static m1 (a: number): void;
+    m1 (a: any): void {
+    }
+}

tests/cases/compiler/nonMergedDeclarationsAndOverloads.ts

@@ -0,0 +1,8 @@
+class A {
+    m1: string;
+    f() {}
+    m1 (a: string): void;
+    m1 (a: number): void;
+    m1 (a: any): void {
+    }
+}

tests/cases/compiler/optionsInlineSourceMapMapRoot.ts

@@ -0,0 +1,4 @@
+// @mapRoot: local
+// @inlineSourceMap: true
+
+var a = 10;

tests/cases/compiler/optionsInlineSourceMapSourceRoot.ts

@@ -0,0 +1,4 @@
+// @sourceRoot: local
+// @inlineSourceMap: true
+
+var a = 10;

tests/cases/compiler/optionsInlineSourceMapSourcemap.ts

@@ -0,0 +1,4 @@
+// @sourcemap: true
+// @inlineSourceMap: true
+
+var a = 10;