Merge pull request #464 from Microsoft/typeWriter

Revive TypeWriter

src/compiler/checker.ts

@@ -36,19 +36,17 @@ module ts {
             getTypeCount: () => typeCount,
             checkProgram: checkProgram,
             emitFiles: invokeEmitter,
-            getSymbolOfNode: getSymbolOfNode,
             getParentOfSymbol: getParentOfSymbol,
             getTypeOfSymbol: getTypeOfSymbol,
-            getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol,
             getPropertiesOfType: getPropertiesOfType,
             getPropertyOfType: getPropertyOfType,
             getSignaturesOfType: getSignaturesOfType,
             getIndexTypeOfType: getIndexTypeOfType,
             getReturnTypeOfSignature: getReturnTypeOfSignature,
-            resolveEntityName: resolveEntityName,
             getSymbolsInScope: getSymbolsInScope,
             getSymbolInfo: getSymbolInfo,
-            getTypeOfExpression: getTypeOfExpression,
+            getTypeOfNode: getTypeOfNode,
+            getApparentType: getApparentType,
             typeToString: typeToString,
             symbolToString: symbolToString,
             getAugmentedPropertiesOfApparentType: getAugmentedPropertiesOfApparentType
@@ -2298,6 +2296,12 @@ module ts {
                     return getTypeFromArrayTypeNode(<ArrayTypeNode>node);
                 case SyntaxKind.TypeLiteral:
                     return getTypeFromTypeLiteralNode(<TypeLiteralNode>node);
+                // This function assumes that an identifier or qualified name is a type expression
+                // Callers should first ensure this by calling isTypeNode
+                case SyntaxKind.Identifier:
+                case SyntaxKind.QualifiedName:
+                    var symbol = getSymbolInfo(node);
+                    return getDeclaredTypeOfSymbol(symbol);
                 default:
                     return unknownType;
             }
@@ -6546,30 +6550,59 @@ module ts {
             return mapToArray(symbols);
         }
 
-        // True if the given identifier is the identifier of a declaration node
-        function isDeclarationIdentifier(identifier: Identifier): boolean {
-            if (identifier.parent) {
-                switch (identifier.parent.kind) {
-                    case SyntaxKind.TypeParameter:
-                    case SyntaxKind.Parameter:
-                    case SyntaxKind.VariableDeclaration:
-                    case SyntaxKind.Property:
-                    case SyntaxKind.PropertyAssignment:
-                    case SyntaxKind.EnumMember:
-                    case SyntaxKind.Method:
-                    case SyntaxKind.FunctionDeclaration:
-                    case SyntaxKind.FunctionExpression:
-                    case SyntaxKind.GetAccessor:
-                    case SyntaxKind.SetAccessor:
-                    case SyntaxKind.ClassDeclaration:
-                    case SyntaxKind.InterfaceDeclaration:
-                    case SyntaxKind.EnumDeclaration:
-                    case SyntaxKind.ModuleDeclaration:
-                    case SyntaxKind.ImportDeclaration:
-                        return (<Declaration>identifier.parent).name === identifier;
-                    case SyntaxKind.CatchBlock:
-                        return (<CatchBlock>identifier.parent).variable === identifier;
-                }
+        // True if the given identifier is the name of a type declaration node (class, interface, enum, type parameter, etc)
+        function isTypeDeclarationName(name: Node): boolean {
+            return name.kind == SyntaxKind.Identifier &&
+                isTypeDeclaration(name.parent) &&
+                (<Declaration>name.parent).name === name;
+        }
+
+        // True if the given identifier, string literal, or number literal is the name of a declaration node
+        function isDeclarationOrFunctionExpressionOrCatchVariableName(name: Node): boolean {
+            if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) {
+                return false;
+            }
+
+            var parent = name.parent;
+            if (isDeclaration(parent) || parent.kind === SyntaxKind.FunctionExpression) {
+                return (<Declaration>parent).name === name;
+            }
+
+            if (parent.kind === SyntaxKind.CatchBlock) {
+                return (<CatchBlock>parent).variable === name;
+            }
+
+            return false;
+        }
+
+        function isTypeDeclaration(node: Node): boolean {
+            switch (node.kind) {
+                case SyntaxKind.TypeParameter:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                    return true;
+            }
+        }
+
+        function isDeclaration(node: Node): boolean {
+            switch (node.kind) {
+                case SyntaxKind.TypeParameter:
+                case SyntaxKind.Parameter:
+                case SyntaxKind.VariableDeclaration:
+                case SyntaxKind.Property:
+                case SyntaxKind.PropertyAssignment:
+                case SyntaxKind.EnumMember:
+                case SyntaxKind.Method:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.ImportDeclaration:
+                    return true;
             }
             return false;
         }
@@ -6603,57 +6636,156 @@ module ts {
                 case SyntaxKind.PostfixOperator:
                 case SyntaxKind.BinaryExpression:
                 case SyntaxKind.ConditionalExpression:
+                case SyntaxKind.OmittedExpression:
                     return true;
                 case SyntaxKind.QualifiedName:
-                    while (node.parent && node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
-                    return node.parent && node.parent.kind === SyntaxKind.TypeQuery;
+                    while (node.parent.kind === SyntaxKind.QualifiedName) node = node.parent;
+                    return node.parent.kind === SyntaxKind.TypeQuery;
                 case SyntaxKind.Identifier:
+                    if (node.parent.kind === SyntaxKind.TypeQuery) {
+                        return true;
+                    }
+                // Fall through
                 case SyntaxKind.NumericLiteral:
                 case SyntaxKind.StringLiteral:
                     var parent = node.parent;
-                    if (parent) {
-                        if (isExpression(parent)) return true;
-                        switch (parent.kind) {
-                            case SyntaxKind.VariableDeclaration:
-                            case SyntaxKind.Parameter:
-                            case SyntaxKind.Property:
-                            case SyntaxKind.EnumMember:
-                                return (<VariableDeclaration>parent).initializer === node;
-                            case SyntaxKind.ExpressionStatement:
-                            case SyntaxKind.IfStatement:
-                            case SyntaxKind.DoStatement:
-                            case SyntaxKind.WhileStatement:
-                            case SyntaxKind.ReturnStatement:
-                            case SyntaxKind.WithStatement:
-                            case SyntaxKind.SwitchStatement:
-                            case SyntaxKind.CaseClause:
-                            case SyntaxKind.ThrowStatement:
-                            case SyntaxKind.SwitchStatement:
-                                return (<ExpressionStatement>parent).expression === node;
-                            case SyntaxKind.ForStatement:
-                                return (<ForStatement>parent).initializer === node || (<ForStatement>parent).condition === node ||
-                                    (<ForStatement>parent).iterator === node;
-                            case SyntaxKind.ForInStatement:
-                                return (<ForInStatement>parent).variable === node || (<ForInStatement>parent).expression === node;
-                        }
+                    switch (parent.kind) {
+                        case SyntaxKind.VariableDeclaration:
+                        case SyntaxKind.Parameter:
+                        case SyntaxKind.Property:
+                        case SyntaxKind.EnumMember:
+                            return (<VariableDeclaration>parent).initializer === node;
+                        case SyntaxKind.ExpressionStatement:
+                        case SyntaxKind.IfStatement:
+                        case SyntaxKind.DoStatement:
+                        case SyntaxKind.WhileStatement:
+                        case SyntaxKind.ReturnStatement:
+                        case SyntaxKind.WithStatement:
+                        case SyntaxKind.SwitchStatement:
+                        case SyntaxKind.CaseClause:
+                        case SyntaxKind.ThrowStatement:
+                        case SyntaxKind.SwitchStatement:
+                            return (<ExpressionStatement>parent).expression === node;
+                        case SyntaxKind.ForStatement:
+                            return (<ForStatement>parent).initializer === node ||
+                                (<ForStatement>parent).condition === node ||
+                                (<ForStatement>parent).iterator === node;
+                        case SyntaxKind.ForInStatement:
+                            return (<ForInStatement>parent).variable === node ||
+                                (<ForInStatement>parent).expression === node;
+                        case SyntaxKind.TypeAssertion:
+                            return node === (<TypeAssertion>parent).operand;
+                        default:
+                            if (isExpression(parent)) {
+                                return true;
+                            }
                     }
             }
             return false;
         }
 
+        function isTypeNode(node: Node): boolean {
+            if (node.kind >= SyntaxKind.FirstTypeNode && node.kind <= SyntaxKind.LastTypeNode) {
+                return true;
+            }
+
+            switch (node.kind) {
+                case SyntaxKind.AnyKeyword:
+                case SyntaxKind.NumberKeyword:
+                case SyntaxKind.StringKeyword:
+                case SyntaxKind.BooleanKeyword:
+                    return true;
+                case SyntaxKind.VoidKeyword:
+                    return node.parent.kind !== SyntaxKind.PrefixOperator;
+                case SyntaxKind.StringLiteral:
+                    // Specialized signatures can have string literals as their parameters' type names
+                    return node.parent.kind === SyntaxKind.Parameter;
+                // Identifiers and qualified names may be type nodes, depending on their context. Climb
+                // above them to find the lowest container
+                case SyntaxKind.Identifier:
+                    // If the identifier is the RHS of a qualified name, then it's a type iff its parent is.
+                    if (node.parent.kind === SyntaxKind.QualifiedName) {
+                        node = node.parent;
+                    }
+                    // Fall through
+                case SyntaxKind.QualifiedName:
+                    // At this point, node is either a qualified name or an identifier
+                    var parent = node.parent;
+                    if (parent.kind === SyntaxKind.TypeQuery) {
+                        return false;
+                    }
+                    // Do not recursively call isTypeNode on the parent. In the example:
+                    //
+                    //     var a: A.B.C;
+                    //
+                    // Calling isTypeNode would consider the qualified name A.B a type node. Only C or
+                    // A.B.C is a type node.
+                    if (parent.kind >= SyntaxKind.FirstTypeNode && parent.kind <= SyntaxKind.LastTypeNode) {
+                        return true;
+                    }
+                    switch (parent.kind) {
+                        case SyntaxKind.TypeParameter:
+                            return node === (<TypeParameterDeclaration>parent).constraint;
+                        case SyntaxKind.Property:
+                        case SyntaxKind.Parameter:
+                        case SyntaxKind.VariableDeclaration:
+                            return node === (<VariableDeclaration>parent).type;
+                        case SyntaxKind.FunctionDeclaration:
+                        case SyntaxKind.FunctionExpression:
+                        case SyntaxKind.ArrowFunction:
+                        case SyntaxKind.Constructor:
+                        case SyntaxKind.Method:
+                        case SyntaxKind.GetAccessor:
+                        case SyntaxKind.SetAccessor:
+                            return node === (<FunctionDeclaration>parent).type;
+                        case SyntaxKind.CallSignature:
+                        case SyntaxKind.ConstructSignature:
+                        case SyntaxKind.IndexSignature:
+                            return node === (<SignatureDeclaration>parent).type;
+                        case SyntaxKind.TypeAssertion:
+                            return node === (<TypeAssertion>parent).type;
+                        case SyntaxKind.CallExpression:
+                        case SyntaxKind.NewExpression:
+                            return (<CallExpression>parent).typeArguments.indexOf(node) >= 0;
+                    }
+            }
+
+            return false;
+        }
+
+        function isInRightSideOfImportOrExportAssignment(node: EntityName) {
+            while (node.parent.kind === SyntaxKind.QualifiedName) {
+                node = node.parent;
+            }
+
+            if (node.parent.kind === SyntaxKind.ImportDeclaration) {
+                return (<ImportDeclaration>node.parent).entityName === node;
+            }
+            if (node.parent.kind === SyntaxKind.ExportAssignment) {
+                return (<ExportAssignment>node.parent).exportName === node;
+            }
+
+            return false;
+        }
+
         function isRightSideOfQualifiedNameOrPropertyAccess(node: Node) {
             return (node.parent.kind === SyntaxKind.QualifiedName || node.parent.kind === SyntaxKind.PropertyAccess) &&
                 (<QualifiedName>node.parent).right === node;
         }
 
-        function getSymbolOfIdentifier(identifier: Identifier) {
-            if (isDeclarationIdentifier(identifier)) {
-                return getSymbolOfNode(identifier.parent);
+        function getSymbolOfEntityName(entityName: EntityName): Symbol {
+            if (isDeclarationOrFunctionExpressionOrCatchVariableName(entityName)) {
+                return getSymbolOfNode(entityName.parent);
             }
 
-            var entityName: Node = identifier;
-            while (isRightSideOfQualifiedNameOrPropertyAccess(entityName))
+            if (entityName.parent.kind === SyntaxKind.ExportAssignment) {
+                return resolveEntityName(/*location*/ entityName.parent.parent, entityName,
+                    /*all meanings*/ SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
+            }
+
+            if (isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
                 entityName = entityName.parent;
+            }
 
             if (isExpression(entityName)) {
                 if (entityName.kind === SyntaxKind.Identifier) {
@@ -6681,12 +6813,17 @@ module ts {
                 meaning |= SymbolFlags.Import;
                 return resolveEntityName(entityName, entityName, meaning);
             }
+
+            // Do we want to return undefined here?
+            return undefined;
         }
 
         function getSymbolInfo(node: Node) {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
-                    return getSymbolOfIdentifier(<Identifier>node);
+                case SyntaxKind.PropertyAccess:
+                case SyntaxKind.QualifiedName:
+                    return getSymbolOfEntityName(<Identifier>node);
 
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.SuperKeyword:
@@ -6725,16 +6862,64 @@ module ts {
             return undefined;
         }
 
-        function getTypeOfExpression(node: Node) {
+        function getTypeOfNode(node: Node): Type {
             if (isExpression(node)) {
-                while (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
-                  node = node.parent;
-                }
-                return <Type>getApparentType(checkExpression(node));
+                return getTypeOfExpression(<Expression>node);
             }
+            if (isTypeNode(node)) {
+                return getTypeFromTypeNode(<TypeNode>node);
+            }
+
+            if (isTypeDeclaration(node)) {
+                // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration
+                var symbol = getSymbolOfNode(node);
+                return getDeclaredTypeOfSymbol(symbol);
+            }
+
+            if (isTypeDeclarationName(node)) {
+                var symbol = getSymbolInfo(node);
+                return getDeclaredTypeOfSymbol(symbol);
+            }
+
+            if (isDeclaration(node)) {
+                // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration
+                var symbol = getSymbolOfNode(node);
+                return getTypeOfSymbol(symbol);
+            }
+
+            if (isDeclarationOrFunctionExpressionOrCatchVariableName(node)) {
+                var symbol = getSymbolInfo(node);
+                return getTypeOfSymbol(symbol);
+            }
+
+            if (isInRightSideOfImportOrExportAssignment(node)) {
+                var symbol: Symbol;
+                if (node.parent.kind === SyntaxKind.ExportAssignment) {
+                    symbol = getSymbolInfo(node);
+                }
+                else {
+                    // It is an import statement
+                    if (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
+                        node = node.parent;
+                    }
+                    // We include all declaration spaces for aliases. This is likely too inclusive, as the rules
+                    // for resolving aliases are quite particular. Ideally this should reuse the logic in resolveAlias.
+                    symbol = resolveEntityName(node, node, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Import);
+                }
+                var declaredType = getDeclaredTypeOfSymbol(symbol);
+                return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
+            }
+
             return unknownType;
         }
 
+        function getTypeOfExpression(expr: Expression): Type {
+            if (isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
+                expr = expr.parent;
+            }
+            return checkExpression(expr);
+        }
+
         function getAugmentedPropertiesOfApparentType(type: Type): Symbol[]{
             var apparentType = getApparentType(type);
 
@@ -6743,13 +6928,13 @@ module ts {
                 var propertiesByName: Map<Symbol> = {};
                 var results: Symbol[] = [];
 
-                forEach(getPropertiesOfType(apparentType), (s) => {
+                forEach(getPropertiesOfType(apparentType), s => {
                     propertiesByName[s.name] = s;
                     results.push(s);
                 });
 
                 var resolved = resolveObjectTypeMembers(<ObjectType>type);
-                forEachValue(resolved.members, (s) => {
+                forEachValue(resolved.members, s => {
                     if (symbolIsValue(s) && !propertiesByName[s.name]) {
                         propertiesByName[s.name] = s;
                         results.push(s);
@@ -6757,7 +6942,7 @@ module ts {
                 });
 
                 if (resolved === anyFunctionType || resolved.callSignatures.length || resolved.constructSignatures.length) {
-                    forEach(getPropertiesOfType(globalFunctionType), (s) => {
+                    forEach(getPropertiesOfType(globalFunctionType), s => {
                         if (!propertiesByName[s.name]) {
                             propertiesByName[s.name] = s;
                             results.push(s);

src/compiler/types.ts

@@ -218,6 +218,8 @@ module ts {
         LastKeyword = StringKeyword,
         FirstFutureReservedWord = ImplementsKeyword,
         LastFutureReservedWord = YieldKeyword,
+        FirstTypeNode = TypeReference,
+        LastTypeNode = ArrayType,
         FirstPunctuation= OpenBraceToken,
         LastPunctuation = CaretEqualsToken
     }
@@ -595,19 +597,17 @@ module ts {
         getTypeCount(): number;
         checkProgram(): void;
         emitFiles(): EmitResult;
-        getSymbolOfNode(node: Node): Symbol;
         getParentOfSymbol(symbol: Symbol): Symbol;
         getTypeOfSymbol(symbol: Symbol): Type;
-        getDeclaredTypeOfSymbol(symbol: Symbol): Type;
         getPropertiesOfType(type: Type): Symbol[];
         getPropertyOfType(type: Type, propetyName: string): Symbol;
         getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
         getIndexTypeOfType(type: Type, kind: IndexKind): Type;
         getReturnTypeOfSignature(signature: Signature): Type;
-        resolveEntityName(location: Node, name: EntityName, meaning: SymbolFlags): Symbol;
         getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
         getSymbolInfo(node: Node): Symbol;
-        getTypeOfExpression(node: Expression, contextualType?: Type, contextualMapper?: TypeMapper): Type;
+        getTypeOfNode(node: Node): Type;
+        getApparentType(type: Type): ApparentType;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
         getAugmentedPropertiesOfApparentType(type: Type): Symbol[];

src/harness/compilerRunner.ts

@@ -39,8 +39,9 @@ class CompilerBaselineRunner extends RunnerBase {
 
     public checkTestCodeOutput(fileName: string) {
         describe('compiler tests for ' + fileName, () => {
-            // strips the fileName from the path.
-            var justName = fileName.replace(/^.*[\\\/]/, '');
+            // Mocha holds onto the closure environment of the describe callback even after the test is done.
+            // Everything declared here should be cleared out in the "after" callback.
+            var justName = fileName.replace(/^.*[\\\/]/, ''); // strips the fileName from the path.
             var content = Harness.IO.readFile(fileName);
             var testCaseContent = Harness.TestCaseParser.makeUnitsFromTest(content, fileName);
 
@@ -52,6 +53,7 @@ class CompilerBaselineRunner extends RunnerBase {
             var rootDir = lastUnit.originalFilePath.indexOf('conformance') === -1 ? 'tests/cases/compiler/' : lastUnit.originalFilePath.substring(0, lastUnit.originalFilePath.lastIndexOf('/')) + '/';
 
             var result: Harness.Compiler.CompilerResult;
+            var checker: ts.TypeChecker;
             var options: ts.CompilerOptions;
             // equivalent to the files that will be passed on the command line
             var toBeCompiled: { unitName: string; content: string }[];
@@ -85,8 +87,10 @@ class CompilerBaselineRunner extends RunnerBase {
                     });
                 }
 
-                options = harnessCompiler.compileFiles(toBeCompiled, otherFiles, function (compileResult) {
+                options = harnessCompiler.compileFiles(toBeCompiled, otherFiles, function (compileResult, _checker) {
                     result = compileResult;
+                    // The checker will be used by typeWriter
+                    checker = _checker;
                 }, function (settings) {
                         harnessCompiler.setCompilerSettings(tcSettings);
                 });
@@ -97,6 +101,7 @@ class CompilerBaselineRunner extends RunnerBase {
                    a fresh compiler instance for themselves and then create a fresh one for the next test. Would be nice to get dev fixes
                    eventually to remove this limitation. */
                 for (var i = 0; i < tcSettings.length; ++i) {
+                    // noImplicitAny is passed to getCompiler, but target is just passed in the settings blob to setCompilerSettings
                     if (!createNewInstance && (tcSettings[i].flag == "noimplicitany" || tcSettings[i].flag === 'target')) {
                         harnessCompiler = Harness.Compiler.getCompiler({
                             useExistingInstance: false,
@@ -118,6 +123,27 @@ class CompilerBaselineRunner extends RunnerBase {
                 }
             });
 
+            after(() => {
+                // Mocha holds onto the closure environment of the describe callback even after the test is done.
+                // Therefore we have to clean out large objects after the test is done.
+                justName = undefined;
+                content = undefined;
+                testCaseContent = undefined;
+                units = undefined;
+                tcSettings = undefined;
+                lastUnit = undefined;
+                rootDir = undefined;
+                result = undefined;
+                checker = undefined;
+                options = undefined;
+                toBeCompiled = undefined;
+                otherFiles = undefined;
+                harnessCompiler = undefined;
+                declToBeCompiled = undefined;
+                declOtherFiles = undefined;
+                declResult = undefined;
+            });
+
             function getByteOrderMarkText(file: Harness.Compiler.GeneratedFile): string {
                 return file.writeByteOrderMark ? "\u00EF\u00BB\u00BF" : "";
             }
@@ -251,32 +277,15 @@ class CompilerBaselineRunner extends RunnerBase {
 
             it('Correct type baselines for ' + fileName, () => {
                 // NEWTODO: Type baselines
-                if (/* ! */ false && /* ! */ result.errors.length === 0) {
+                if (result.errors.length === 0) {
                     Harness.Baseline.runBaseline('Correct expression types for ' + fileName, justName.replace(/\.ts/, '.types'), () => {
-                        // TODO: Rewrite this part
-                        //var compiler = new TypeScript.TypeScriptCompiler(
-                        //    new TypeScript.NullLogger(), TypeScript.ImmutableCompilationSettings.defaultSettings());
-
-                        //compiler.addFile('lib.d.ts', TypeScript.ScriptSnapshot.fromString(Harness.Compiler.libTextMinimal),
-                        //    TypeScript.ByteOrderMark.None, /*version:*/ "0", /*isOpen:*/ true);
-
-                        //var allFiles = toBeCompiled.concat(otherFiles);
-                        //allFiles.forEach(file => {
-                        //    compiler.addFile(file.unitName, TypeScript.ScriptSnapshot.fromString(file.content),
-                        //        TypeScript.ByteOrderMark.None, /*version:*/ "0", /*isOpen:*/ true);
-                        //});
-
-                        var allFiles: any[] = [];
-                        var compiler: any = undefined;
-
-                        var typeBaselineText = '';
+                        var allFiles = toBeCompiled.concat(otherFiles).filter(file => !!checker.getProgram().getSourceFile(file.unitName));
                         var typeLines: string[] = [];
                         var typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
+                        var walker = new TypeWriterWalker(checker);
                         allFiles.forEach(file => {
                             var codeLines = file.content.split('\n');
-                            var walker = new TypeWriterWalker(file.unitName, compiler);
-                            walker.run();
-                            walker.results.forEach(result => {
+                            walker.getTypes(file.unitName).forEach(result => {
                                 var formattedLine = result.identifierName + " : " + result.type;
                                 if (!typeMap[file.unitName]) {
                                     typeMap[file.unitName] = {};
@@ -290,23 +299,6 @@ class CompilerBaselineRunner extends RunnerBase {
                                 typeMap[file.unitName][result.line] = typeInfo;
                             });
 
-                            var typeBaselineText = '';
-                            var typeLines: string[] = [];
-                            var typeMap: { [fileName: string]: { [lineNum: number]: string[]; } } = {};
-                            allFiles.forEach(file => {
-                                var codeLines = file.content.split('\n');
-                                var walker = new TypeWriterWalker(file.unitName, compiler);
-                                walker.run();
-                                walker.results.forEach(result => {
-                                    var formattedLine = result.identifierName + " : " + result.type;
-                                    if (!typeMap[file.unitName]) {
-                                        typeMap[file.unitName] = {};
-                                    } else {
-                                        typeLines.push('No type information for this code.');
-                                    }
-                                });
-                            });
-
                             typeLines.push('=== ' + file.unitName + ' ===\r\n');
                             for (var i = 0; i < codeLines.length; i++) {
                                 var currentCodeLine = codeLines[i];

src/harness/harness.ts

@@ -609,7 +609,7 @@ module Harness {
 
             public compileFiles(inputFiles: { unitName: string; content: string }[],
                 otherFiles: { unitName: string; content?: string }[],
-                onComplete: (result: CompilerResult) => void,
+                onComplete: (result: CompilerResult, checker: ts.TypeChecker) => void,
                 settingsCallback?: (settings: ts.CompilerOptions) => void,
                 options?: ts.CompilerOptions) {
 
@@ -755,7 +755,7 @@ module Harness {
                 var result = new CompilerResult(fileOutputs, errors, []);
                 // Covert the source Map data into the baseline
                 result.updateSourceMapRecord(program, emitResult ? emitResult.sourceMaps : undefined);
-                onComplete(result);
+                onComplete(result, checker);
 
                 // reset what newline means in case the last test changed it
                 sys.newLine = '\r\n';

src/harness/typeWriter.ts

@@ -1,180 +1,99 @@
-
-/** TODO: Rewrite entirely **/
-class TypeWriterWalker {
-    constructor(public filename: string, public compiler: any) {
-    }
-    public run() { }
-    public results: any[];
+interface TypeWriterResult {
+    line: number;
+    column: number;
+    syntaxKind: string;
+    identifierName: string;
+    type: string;
 }
 
-/*
-class TypeWriterWalker extends TypeScript.SyntaxWalker {
-    private document: TypeScript.Document;
-    private syntaxTree: TypeScript.SyntaxTree;
-    private text: TypeScript.ISimpleText;
-    private currentPosition = 0;
+class TypeWriterWalker {
+    results: TypeWriterResult[];
+    currentSourceFile: ts.SourceFile;
 
-    public results: {
-        line: number;
-        column: number;
-        syntaxKind: string;
-        identifierName: string;
-        type: string;
-    }[] = [];
-
-    constructor(public filename: string, public compiler: TypeScript.TypeScriptCompiler) {
-        super();
-
-        this.document = compiler.getDocument(filename);
-        this.syntaxTree = this.document.syntaxTree();
-        this.text = this.syntaxTree.text;
+    constructor(public checker: ts.TypeChecker) {
     }
 
-    public run() {
-        TypeScript.visitNodeOrToken(this, this.syntaxTree.sourceUnit());
+    public getTypes(fileName: string): TypeWriterResult[] {
+        var sourceFile = this.checker.getProgram().getSourceFile(fileName);
+        this.currentSourceFile = sourceFile;
+        this.results = [];
+        this.visitNode(sourceFile);
+        return this.results;
     }
 
-    private isName(token: TypeScript.ISyntaxToken) {
-        var parent = token.parent;
+    private visitNode(node: ts.Node): void {
+        switch (node.kind) {
+            // Should always log expressions that are not tokens
+            // Also, always log the "this" keyword
+            // TODO: Ideally we should log all expressions, but to compare to the
+            // old typeWriter baselines, suppress tokens
+            case ts.SyntaxKind.ThisKeyword:
+            case ts.SyntaxKind.RegularExpressionLiteral:
+            case ts.SyntaxKind.ArrayLiteral:
+            case ts.SyntaxKind.ObjectLiteral:
+            case ts.SyntaxKind.PropertyAccess:
+            case ts.SyntaxKind.IndexedAccess:
+            case ts.SyntaxKind.CallExpression:
+            case ts.SyntaxKind.NewExpression:
+            case ts.SyntaxKind.TypeAssertion:
+            case ts.SyntaxKind.ParenExpression:
+            case ts.SyntaxKind.FunctionExpression:
+            case ts.SyntaxKind.ArrowFunction:
+            case ts.SyntaxKind.PrefixOperator:
+            case ts.SyntaxKind.PostfixOperator:
+            case ts.SyntaxKind.BinaryExpression:
+            case ts.SyntaxKind.ConditionalExpression:
+                this.log(node, this.getTypeOfNode(node));
+                break;
 
-        switch (parent.kind()) {
-            case TypeScript.SyntaxKind.ContinueStatement:
-                return (<TypeScript.ContinueStatementSyntax>parent).identifier === token;
-            case TypeScript.SyntaxKind.BreakStatement:
-                return (<TypeScript.BreakStatementSyntax>parent).identifier === token;
-            case TypeScript.SyntaxKind.LabeledStatement:
-                return (<TypeScript.LabeledStatementSyntax>parent).identifier === token;
+            // Should not change expression status (maybe expressions)
+            // TODO: Again, ideally should log number and string literals too,
+            // but to be consistent with the old typeWriter, just log identifiers
+            case ts.SyntaxKind.Identifier:
+                var identifier = <ts.Identifier>node;
+                if (!this.isLabel(identifier)) {
+                    var type = this.getTypeOfNode(identifier);
+                    this.log(node, type);
+                }
+                break;
+        }
+
+        ts.forEachChild(node, child => this.visitNode(child));
+    }
+
+    private isLabel(identifier: ts.Identifier): boolean {
+        var parent = identifier.parent;
+        switch (parent.kind) {
+            case ts.SyntaxKind.ContinueStatement:
+            case ts.SyntaxKind.BreakStatement:
+                return (<ts.BreakOrContinueStatement>parent).label === identifier;
+            case ts.SyntaxKind.LabelledStatement:
+                return (<ts.LabelledStatement>parent).label === identifier;
         }
         return false;
     }
 
-    public visitToken(token: TypeScript.ISyntaxToken) {
-        if (token.kind() === TypeScript.SyntaxKind.IdentifierName) {
-            if (!this.isName(token)) {
-                this.log(token);
-            }
-        } else if (token.kind() === TypeScript.SyntaxKind.ThisKeyword) {
-            this.log(token);
-        }
-        return super.visitToken(token);
+    private log(node: ts.Node, type: ts.Type): void {
+        var actualPos = ts.skipTrivia(this.currentSourceFile.text, node.pos);
+        var lineAndCharacter = this.currentSourceFile.getLineAndCharacterFromPosition(actualPos);
+        var sourceText = ts.getSourceTextOfNodeFromSourceText(this.currentSourceFile.text, node);
+        var isUnknownType = (<ts.IntrinsicType>type).intrinsicName === "unknown";
+        
+        // If we got an unknown type, we temporarily want to fall back to just pretending the name
+        // (source text) of the node is the type. This is to align with the old typeWriter to make
+        // baseline comparisons easier. In the long term, we will want to just call typeToString
+        this.results.push({
+            line: lineAndCharacter.line - 1,
+            column: lineAndCharacter.character,
+            syntaxKind: ts.SyntaxKind[node.kind],
+            identifierName: sourceText,
+            type: isUnknownType ? sourceText : this.checker.typeToString(type)
+        });
     }
 
-    public visitNode(node: TypeScript.ISyntaxNode) {
-        return super.visitNode(node);
-    }
-
-    private getAstForElement(element: TypeScript.ISyntaxElement) {
-        if (!TypeScript.isShared(element)) {
-            return element;
-        }
-    }
-
-    private getEnclosingScopeSymbol(ast: TypeScript.ISyntaxElement): TypeScript.PullSymbol {
-        var enclosingScopeAST = TypeScript.DeclarationEmitter.getEnclosingContainer(ast);
-        if (enclosingScopeAST) {
-            var typeInfo = this.compiler.pullGetSymbolInformationFromAST(enclosingScopeAST, this.document);
-            return typeInfo ? typeInfo.symbol : null;
-        }
-
-        return null;
-    }
-
-    private getTypeOfElement(element: TypeScript.ISyntaxElement) {
-        var ast = this.getAstForElement(element);
-        if (ast) {
-            var typeInfo = this.compiler.pullGetSymbolInformationFromAST(ast, this.document);
-            if (typeInfo.symbol && typeInfo.symbol.type) {
-                var enclosingScope = this.getEnclosingScopeSymbol(ast);
-                return typeInfo.symbol.type.toString(enclosingScope);
-            }
-        }
-
-        return "<unknown>";
-    }
-
-    public visitPrefixUnaryExpression(node: TypeScript.PrefixUnaryExpressionSyntax) {
-        this.log(node);
-        return super.visitPrefixUnaryExpression(node);
-    }
-    public visitArrayLiteralExpression(node: TypeScript.ArrayLiteralExpressionSyntax) {
-        this.log(node);
-        return super.visitArrayLiteralExpression(node);
-    }
-    public visitOmittedExpression(node: TypeScript.OmittedExpressionSyntax) {
-        this.log(node);
-        return super.visitOmittedExpression(node);
-    }
-    public visitParenthesizedExpression(node: TypeScript.ParenthesizedExpressionSyntax) {
-        this.log(node);
-        return super.visitParenthesizedExpression(node);
-    }
-    public visitSimpleArrowFunctionExpression(node: TypeScript.SimpleArrowFunctionExpressionSyntax) {
-        this.log(node);
-        return super.visitSimpleArrowFunctionExpression(node);
-    }
-    public visitParenthesizedArrowFunctionExpression(node: TypeScript.ParenthesizedArrowFunctionExpressionSyntax) {
-        this.log(node);
-        return super.visitParenthesizedArrowFunctionExpression(node);
-    }
-    public visitObjectCreationExpression(node: TypeScript.ObjectCreationExpressionSyntax) {
-        this.log(node);
-        return super.visitObjectCreationExpression(node);
-    }
-    public visitCastExpression(node: TypeScript.CastExpressionSyntax) {
-        this.log(node);
-        return super.visitCastExpression(node);
-    }
-    public visitObjectLiteralExpression(node: TypeScript.ObjectLiteralExpressionSyntax) {
-        this.log(node);
-        return super.visitObjectLiteralExpression(node);
-    }
-    public visitFunctionExpression(node: TypeScript.FunctionExpressionSyntax) {
-        this.log(node);
-        return super.visitFunctionExpression(node);
-    }
-    public visitTypeOfExpression(node: TypeScript.TypeOfExpressionSyntax) {
-        this.log(node);
-        return super.visitTypeOfExpression(node);
-    }
-    public visitDeleteExpression(node: TypeScript.DeleteExpressionSyntax) {
-        this.log(node);
-        return super.visitDeleteExpression(node);
-    }
-    public visitVoidExpression(node: TypeScript.VoidExpressionSyntax) {
-        this.log(node);
-        return super.visitVoidExpression(node);
-    }
-    public visitMemberAccessExpression(node: TypeScript.MemberAccessExpressionSyntax) {
-        this.log(node);
-        return super.visitMemberAccessExpression(node);
-    }
-    public visitPostfixUnaryExpression(node: TypeScript.PostfixUnaryExpressionSyntax) {
-        this.log(node);
-        return super.visitPostfixUnaryExpression(node);
-    }
-    public visitElementAccessExpression(node: TypeScript.ElementAccessExpressionSyntax) {
-        this.log(node);
-        return super.visitElementAccessExpression(node);
-    }
-    public visitInvocationExpression(node: TypeScript.InvocationExpressionSyntax) {
-        this.log(node);
-        return super.visitInvocationExpression(node);
-    }
-    public visitBinaryExpression(node: TypeScript.BinaryExpressionSyntax) {
-        this.log(node);
-        return super.visitBinaryExpression(node);
-    }
-    public visitConditionalExpression(node: TypeScript.ConditionalExpressionSyntax) {
-        this.log(node);
-        return super.visitConditionalExpression(node);
-    }
-
-    public log(node: TypeScript.ISyntaxNodeOrToken) {
-        var _fullStart = TypeScript.fullStart(node);
-        if (_fullStart >= 0) {
-            var pos = this.document.lineMap().getLineAndCharacterFromPosition(_fullStart);
-            this.results.push({ line: pos.line(), column: pos.character(), syntaxKind: TypeScript.SyntaxKind[node.kind()], identifierName: TypeScript.fullText(node, this.text).trim(), type: this.getTypeOfElement(node) });
-        }
+    private getTypeOfNode(node: ts.Node): ts.Type {
+        var type = this.checker.getTypeOfNode(node);
+        ts.Debug.assert(type, "type doesn't exist");
+        return type;
     }
 }
-*/

src/services/services.ts

@@ -1693,7 +1693,7 @@ module ts {
 
             // Right of dot member completion list
             if (isRightOfDot) {
-                var type: Type = typeInfoResolver.getTypeOfExpression(mappedNode);
+                var type: ApparentType = typeInfoResolver.getApparentType(typeInfoResolver.getTypeOfNode(mappedNode));
                 if (!type) {
                     return undefined;
                 }

tests/baselines/reference/2dArrays.types

@@ -0,0 +1,40 @@
+=== tests/cases/compiler/2dArrays.ts ===
+class Cell {
+>Cell : Cell
+}
+
+class Ship {
+>Ship : Ship
+
+    isSunk: boolean;
+>isSunk : boolean
+}
+
+class Board {
+>Board : Board
+
+    ships: Ship[];
+>ships : Ship[]
+>Ship : Ship
+
+    cells: Cell[];
+>cells : Cell[]
+>Cell : Cell
+
+    private allShipsSunk() {
+>allShipsSunk : () => boolean
+
+        return this.ships.every(function (val) { return val.isSunk; });
+>this.ships.every(function (val) { return val.isSunk; }) : boolean
+>this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>this.ships : Ship[]
+>this : Board
+>ships : Ship[]
+>every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean
+>function (val) { return val.isSunk; } : (val: Ship) => boolean
+>val : Ship
+>val.isSunk : boolean
+>val : Ship
+>isSunk : boolean
+    }    
+}

tests/baselines/reference/AmbientModuleAndAmbientFunctionWithTheSameNameAndCommonRoot.types

@@ -0,0 +1,33 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module Point {
+>Point : typeof Point
+
+    export var Origin: { x: number; y: number; }
+>Origin : { x: number; y: number; }
+>x : number
+>y : number
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/function.d.ts ===
+declare function Point(): { x: number; y: number; }
+>Point : typeof Point
+>x : number
+>y : number
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var cl: { x: number; y: number; }
+>cl : { x: number; y: number; }
+>x : number
+>y : number
+
+var cl = Point();
+>cl : { x: number; y: number; }
+>Point() : { x: number; y: number; }
+>Point : typeof Point
+
+var cl = Point.Origin;
+>cl : { x: number; y: number; }
+>Point.Origin : { x: number; y: number; }
+>Point : typeof Point
+>Origin : { x: number; y: number; }
+

tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types

@@ -0,0 +1,59 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module A {
+>A : typeof A
+
+    export module Point {
+>Point : typeof Point
+
+        export var Origin: {
+>Origin : { x: number; y: number; }
+
+            x: number;
+>x : number
+
+            y: number;
+>y : number
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/class.d.ts ===
+declare module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        constructor(x: number, y: number);
+>x : number
+>y : number
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var p: { x: number; y: number; }
+>p : { x: number; y: number; }
+>x : number
+>y : number
+
+var p = A.Point.Origin;
+>p : { x: number; y: number; }
+>A.Point.Origin : { x: number; y: number; }
+>A.Point : typeof Point
+>A : typeof A
+>Point : typeof Point
+>Origin : { x: number; y: number; }
+
+var p = new A.Point(0, 0); // unexpected error here, bug 840000
+>p : { x: number; y: number; }
+>new A.Point(0, 0) : Point
+>A.Point : typeof Point
+>A : typeof A
+>Point : typeof Point
+ 

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types

@@ -0,0 +1,53 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module A {
+>A : typeof A
+
+    export module Point {
+>Point : typeof Point
+
+        export var Origin: {
+>Origin : { x: number; y: number; }
+
+            x: number;
+>x : number
+
+            y: number;
+>y : number
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/classPoint.ts ===
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var p: { x: number; y: number; }
+>p : { x: number; y: number; }
+>x : number
+>y : number
+
+var p = A.Point.Origin;
+>p : { x: number; y: number; }
+>A.Point.Origin : { x: number; y: number; }
+>A.Point : typeof Point
+>A : typeof A
+>Point : typeof Point
+>Origin : { x: number; y: number; }
+
+var p = new A.Point(0, 0); // unexpected error here, bug 840000
+>p : { x: number; y: number; }
+>new A.Point(0, 0) : Point
+>A.Point : typeof Point
+>A : typeof A
+>Point : typeof Point
+

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.types

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.d.ts ===
+declare module Point {
+>Point : typeof Point
+
+    export var Origin: { x: number; y: number; }
+>Origin : { x: number; y: number; }
+>x : number
+>y : number
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
+function Point() {
+>Point : typeof Point
+
+    return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var cl: { x: number; y: number; }
+>cl : { x: number; y: number; }
+>x : number
+>y : number
+
+var cl = Point();
+>cl : { x: number; y: number; }
+>Point() : { x: number; y: number; }
+>Point : typeof Point
+
+var cl = Point.Origin;
+>cl : { x: number; y: number; }
+>Point.Origin : { x: number; y: number; }
+>Point : typeof Point
+>Origin : { x: number; y: number; }
+

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -0,0 +1,49 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.ts ===
+class Point {
+>Point : Point
+
+    constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+
+    static Origin(): Point { return { x: 0, y: 0 }; }
+>Origin : () => Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+}
+
+module Point {
+>Point : typeof Point
+
+    function Origin() { return ""; }// not an error, since not exported
+>Origin : () => string
+}
+
+
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+
+        static Origin(): Point { return { x: 0, y: 0 }; }
+>Origin : () => Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+    }
+
+    export module Point {
+>Point : typeof Point
+
+        function Origin() { return ""; }// not an error since not exported
+>Origin : () => string
+    }
+}

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

@@ -0,0 +1,49 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.ts ===
+class Point {
+>Point : Point
+
+    constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+
+    static Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+}
+
+module Point {
+>Point : typeof Point
+
+    var Origin = ""; // not an error, since not exported
+>Origin : string
+}
+
+
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+
+        static Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+    }
+
+    export module Point {
+>Point : typeof Point
+
+        var Origin = ""; // not an error since not exported
+>Origin : string
+    }
+}

tests/baselines/reference/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.types

@@ -0,0 +1,3 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ClassAndModuleThatMergeWithStringIndexerAndExportedFunctionWithTypeIncompatibleWithIndexer.ts ===
+ 
+No type information for this code.

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types

@@ -0,0 +1,43 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/EnumAndModuleWithSameNameAndCommonRoot.ts ===
+enum enumdule {
+>enumdule : enumdule
+
+    Red, Blue
+>Red : enumdule
+>Blue : enumdule
+}
+
+module enumdule {
+>enumdule : typeof enumdule
+
+    export class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+    }
+}
+
+var x: enumdule;
+>x : enumdule
+>enumdule : enumdule
+
+var x = enumdule.Red;
+>x : enumdule
+>enumdule.Red : enumdule
+>enumdule : typeof enumdule
+>Red : enumdule
+
+var y: { x: number; y: number };
+>y : { x: number; y: number; }
+>x : number
+>y : number
+
+var y = new enumdule.Point(0, 0);
+>y : { x: number; y: number; }
+>new enumdule.Point(0, 0) : Point
+>enumdule.Point : typeof Point
+>enumdule : typeof enumdule
+>Point : typeof Point
+

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types

@@ -0,0 +1,38 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWhichExtendsInterfaceWithInaccessibleType.ts ===
+module A {
+>A : typeof A
+
+    interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+
+        fromOrigin(p: Point): number;
+>fromOrigin : (p: Point) => number
+>p : Point
+>Point : Point
+    }
+
+    export class Point2d implements Point {
+>Point2d : Point2d
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+
+        fromOrigin(p: Point) {
+>fromOrigin : (p: Point) => number
+>p : Point
+>Point : Point
+
+            return 1;
+        }
+    }
+}
+
+

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -0,0 +1,50 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    export class Point3d extends Point {
+>Point3d : Point3d
+>Point : Point
+
+        z: number;
+>z : number
+    }
+
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Point3d
+>Point3d : Point3d
+>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>x : number
+>y : number
+>z : number
+
+    export class Line<TPoint extends Point>{
+>Line : Line<TPoint>
+>TPoint : TPoint
+>Point : Point
+
+        constructor(public start: TPoint, public end: TPoint) { }
+>start : TPoint
+>TPoint : TPoint
+>end : TPoint
+>TPoint : TPoint
+    }
+}
+

tests/baselines/reference/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.types

@@ -0,0 +1,28 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
+module A {
+>A : typeof A
+
+    class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export class points {
+>points : points
+
+        [idx: number]: Point;
+>idx : number
+>Point : Point
+
+        [idx: string]: Point;
+>idx : string
+>Point : Point
+    }
+}
+
+

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -0,0 +1,60 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportClassWithInaccessibleTypeInTypeParameterConstraint.ts ===
+module A {
+>A : typeof A
+
+    class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    export class Point3d extends Point {
+>Point3d : Point3d
+>Point : Point
+
+        z: number;
+>z : number
+    }
+
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Point3d
+>Point3d : Point3d
+>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>x : number
+>y : number
+>z : number
+
+    export class Line<TPoint extends Point>{
+>Line : Line<TPoint>
+>TPoint : TPoint
+>Point : Point
+
+        constructor(public start: TPoint, public end: TPoint) { }
+>start : TPoint
+>TPoint : TPoint
+>end : TPoint
+>TPoint : TPoint
+
+        static fromorigin2d(p: Point): Line<Point>{
+>fromorigin2d : (p: Point) => Line<Point>
+>p : Point
+>Point : Point
+>Line : Line<TPoint>
+>Point : Point
+
+            return null;
+        }
+    }
+}
+

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -0,0 +1,39 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.ts ===
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export class Line {
+>Line : Line
+
+        constructor(public start: Point, public end: Point) { }
+>start : Point
+>Point : Point
+>end : Point
+>Point : Point
+    }
+
+    export function fromOrigin(p: Point): Line {
+>fromOrigin : (p: Point) => Line
+>p : Point
+>Point : Point
+>Line : Line
+
+        return new Line({ x: 0, y: 0 }, p);
+>new Line({ x: 0, y: 0 }, p) : Line
+>Line : typeof Line
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+>p : Point
+    }
+}

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

@@ -0,0 +1,39 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.ts ===
+module A {
+>A : typeof A
+
+    class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export class Line {
+>Line : Line
+
+        constructor(public start: Point, public end: Point) { }
+>start : Point
+>Point : Point
+>end : Point
+>Point : Point
+    }
+
+    export function fromOrigin(p: Point): Line {
+>fromOrigin : (p: Point) => Line
+>p : Point
+>Point : Point
+>Line : Line
+
+        return new Line({ x: 0, y: 0 }, p);
+>new Line({ x: 0, y: 0 }, p) : Line
+>Line : typeof Line
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+>p : Point
+    }
+}

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

@@ -0,0 +1,39 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.ts ===
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    class Line {
+>Line : Line
+
+        constructor(public start: Point, public end: Point) { }
+>start : Point
+>Point : Point
+>end : Point
+>Point : Point
+    }
+
+    export function fromOrigin(p: Point): Line {
+>fromOrigin : (p: Point) => Line
+>p : Point
+>Point : Point
+>Line : Line
+
+        return new Line({ x: 0, y: 0 }, p);
+>new Line({ x: 0, y: 0 }, p) : Line
+>Line : typeof Line
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+>p : Point
+    }
+}

tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -0,0 +1,58 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.ts ===
+module A {
+>A : typeof A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    export interface Point3d extends Point {
+>Point3d : Point3d
+>Point : Point
+
+        z: number;
+>z : number
+    }
+
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Point3d
+>Point3d : Point3d
+>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>x : number
+>y : number
+>z : number
+
+    export interface Line<TPoint extends Point>{
+>Line : Line<TPoint>
+>TPoint : TPoint
+>Point : Point
+
+        new (start: TPoint, end: TPoint);
+>start : TPoint
+>TPoint : TPoint
+>end : TPoint
+>TPoint : TPoint
+
+        start: TPoint;
+>start : TPoint
+>TPoint : TPoint
+
+        end: TPoint;
+>end : TPoint
+>TPoint : TPoint
+    }
+}
+

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.types

@@ -0,0 +1,28 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInIndexerTypeAnnotations.ts ===
+module A {
+>A : A
+
+    interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export interface points {
+>points : points
+
+        [idx: number]: Point;
+>idx : number
+>Point : Point
+
+        [idx: string]: Point;
+>idx : string
+>Point : Point
+    }
+}
+
+

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.types

@@ -0,0 +1,58 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.ts ===
+module A {
+>A : typeof A
+
+    interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    export interface Point3d extends Point {
+>Point3d : Point3d
+>Point : Point
+
+        z: number;
+>z : number
+    }
+
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Point3d
+>Point3d : Point3d
+>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>x : number
+>y : number
+>z : number
+
+    export interface Line<TPoint extends Point>{
+>Line : Line<TPoint>
+>TPoint : TPoint
+>Point : Point
+
+        new (start: TPoint, end: TPoint);
+>start : TPoint
+>TPoint : TPoint
+>end : TPoint
+>TPoint : TPoint
+
+        start: TPoint;
+>start : TPoint
+>TPoint : TPoint
+
+        end: TPoint;
+>end : TPoint
+>TPoint : TPoint
+    }
+}
+

tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types

@@ -0,0 +1,48 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportModuleWithAccessibleTypesOnItsExportedMembers.ts ===
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+    }
+
+    export module B {
+>B : typeof B
+
+        export var Origin: Point = new Point(0, 0);
+>Origin : Point
+>Point : Point
+>new Point(0, 0) : Point
+>Point : typeof Point
+
+        export class Line {
+>Line : Line
+
+            constructor(start: Point, end: Point) {
+>start : Point
+>Point : Point
+>end : Point
+>Point : Point
+
+            }
+
+            static fromOrigin(p: Point) {
+>fromOrigin : (p: Point) => Line
+>p : Point
+>Point : Point
+
+                return new Line({ x: 0, y: 0 }, p);
+>new Line({ x: 0, y: 0 }, p) : Line
+>Line : typeof Line
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+>p : Point
+            }
+        }
+    }
+}

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.types

@@ -0,0 +1,30 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.ts ===
+module A {
+>A : typeof A
+
+    class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+    }
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
+>Unity : { start: Point; end: Point; }
+>{ start: new Point(0, 0), end: new Point(1, 0) } : { start: Point; end: Point; }
+>start : Point
+>new Point(0, 0) : Point
+>Point : typeof Point
+>end : Point
+>new Point(1, 0) : Point
+>Point : typeof Point
+}
+

tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.types

@@ -0,0 +1,22 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts ===
+module A {
+>A : typeof A
+
+    class B {
+>B : B
+
+        id: number;
+>id : number
+    }
+
+    export var beez: Array<B>;
+>beez : B[]
+>Array : T[]
+>B : B
+
+    export var beez2 = new Array<B>();
+>beez2 : B[]
+>new Array<B>() : B[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+>B : B
+}

tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.types

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithAccessibleTypeInTypeAnnotation.ts ===
+module A {
+>A : typeof A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    // valid since Point is exported
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+}
+

tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.types

@@ -0,0 +1,40 @@
+=== tests/cases/conformance/internalModules/exportDeclarations/ExportVariableWithInaccessibleTypeInTypeAnnotation.ts ===
+module A {
+>A : typeof A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    // valid since Point is exported
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    interface Point3d extends Point {
+>Point3d : Point3d
+>Point : Point
+
+        z: number;
+>z : number
+    }
+
+    // invalid Point3d is not exported
+    export var Origin3d: Point3d = { x: 0, y: 0, z: 0 };
+>Origin3d : Point3d
+>Point3d : Point3d
+>{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
+>x : number
+>y : number
+>z : number
+}
+

tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types

@@ -0,0 +1,54 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/function.ts ===
+module A {
+>A : typeof A
+
+    export function Point() {
+>Point : () => { x: number; y: number; }
+
+        return { x: 0, y: 0 };
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/module.ts ===
+module B {
+>B : typeof B
+
+    export module Point {
+>Point : typeof Point
+
+        export var Origin = { x: 0, y: 0 };
+>Origin : { x: number; y: number; }
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===
+var fn: () => { x: number; y: number };
+>fn : () => { x: number; y: number; }
+>x : number
+>y : number
+
+var fn = A.Point;
+>fn : () => { x: number; y: number; }
+>A.Point : () => { x: number; y: number; }
+>A : typeof A
+>Point : () => { x: number; y: number; }
+
+var cl: { x: number; y: number; }
+>cl : { x: number; y: number; }
+>x : number
+>y : number
+
+var cl = B.Point.Origin;
+>cl : { x: number; y: number; }
+>B.Point.Origin : { x: number; y: number; }
+>B.Point : typeof Point
+>B : typeof B
+>Point : typeof Point
+>Origin : { x: number; y: number; }
+

tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types

@@ -0,0 +1,43 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/ModuleAndEnumWithSameNameAndCommonRoot.ts ===
+module enumdule {
+>enumdule : typeof enumdule
+
+    export class Point {
+>Point : Point
+
+        constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+    }
+}
+
+enum enumdule {
+>enumdule : enumdule
+
+    Red, Blue
+>Red : enumdule
+>Blue : enumdule
+}
+
+var x: enumdule;
+>x : enumdule
+>enumdule : enumdule
+
+var x = enumdule.Red;
+>x : enumdule
+>enumdule.Red : enumdule
+>enumdule : typeof enumdule
+>Red : enumdule
+
+var y: { x: number; y: number };
+>y : { x: number; y: number; }
+>x : number
+>y : number
+
+var y = new enumdule.Point(0, 0);
+>y : { x: number; y: number; }
+>new enumdule.Point(0, 0) : Point
+>enumdule.Point : typeof Point
+>enumdule : typeof enumdule
+>Point : typeof Point
+

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types

@@ -0,0 +1,97 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.ts ===
+module A {
+>A : typeof A
+
+    export class Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+}
+
+module A {
+>A : typeof A
+
+    class Point {
+>Point : Point
+
+        fromCarthesian(p: A.Point) {
+>fromCarthesian : (p: Point) => { x: number; y: number; }
+>p : Point
+>A : A
+>Point : Point
+
+            return { x: p.x, y: p.y };
+>{ x: p.x, y: p.y } : { x: number; y: number; }
+>x : number
+>p.x : number
+>p : Point
+>x : number
+>y : number
+>p.y : number
+>p : Point
+>y : number
+        }
+    }
+}
+
+// ensure merges as expected
+var p: { x: number; y: number; };
+>p : { x: number; y: number; }
+>x : number
+>y : number
+
+var p: A.Point;
+>p : { x: number; y: number; }
+>A : A
+>Point : Point
+
+module X.Y.Z {
+>X : typeof X
+>Y : typeof Y
+>Z : typeof Z
+
+    export class Line {
+>Line : Line
+
+        length: number;
+>length : number
+    }
+}
+
+module X {
+>X : typeof X
+
+    export module Y {
+>Y : typeof Y
+
+        export module Z {
+>Z : typeof Z
+
+            class Line {
+>Line : Line
+
+                name: string;
+>name : string
+            }
+        }
+    }
+}
+
+// ensure merges as expected
+var l: { length: number; }
+>l : { length: number; }
+>length : number
+
+var l: X.Y.Z.Line;
+>l : { length: number; }
+>X : X
+>Y : Y
+>Z : Z
+>Line : Line
+
+

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types

@@ -0,0 +1,103 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.ts ===
+module A {
+>A : A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+
+        toCarth(): Point;
+>toCarth : () => Point
+>Point : Point
+    }
+}
+
+module A {
+>A : A
+
+    interface Point {
+>Point : Point
+
+        fromCarth(): Point;
+>fromCarth : () => Point
+>Point : Point
+    }
+}
+
+// ensure merges as expected
+var p: { x: number; y: number; toCarth(): A.Point; };
+>p : { x: number; y: number; toCarth(): Point; }
+>x : number
+>y : number
+>toCarth : () => Point
+>A : A
+>Point : Point
+
+var p: A.Point;
+>p : { x: number; y: number; toCarth(): Point; }
+>A : A
+>Point : Point
+
+module X.Y.Z {
+>X : X
+>Y : Y
+>Z : Z
+
+    export interface Line {
+>Line : Line
+
+        new (start: A.Point, end: A.Point);
+>start : Point
+>A : A
+>Point : Point
+>end : Point
+>A : A
+>Point : Point
+    }
+}
+
+module X {
+>X : X
+
+    export module Y.Z {
+>Y : Y
+>Z : Z
+
+        interface Line {
+>Line : Line
+
+            start: A.Point;
+>start : Point
+>A : A
+>Point : Point
+
+            end: A.Point;
+>end : Point
+>A : A
+>Point : Point
+        }
+    }
+}
+
+// ensure merges as expected
+var l: { new (s: A.Point, e: A.Point); }
+>l : new (s: Point, e: Point) => any
+>s : Point
+>A : A
+>Point : Point
+>e : Point
+>A : A
+>Point : Point
+
+var l: X.Y.Z.Line;
+>l : new (s: Point, e: Point) => any
+>X : X
+>Y : Y
+>Z : Z
+>Line : Line
+

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types

@@ -0,0 +1,125 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
+module A {
+>A : typeof A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export module Utils {
+>Utils : typeof Utils
+
+        export function mirror<T extends Point>(p: T) {
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>T : T
+>Point : Point
+>p : T
+>T : T
+
+            return { x: p.y, y: p.x };
+>{ x: p.y, y: p.x } : { x: number; y: number; }
+>x : number
+>p.y : number
+>p : T
+>y : number
+>y : number
+>p.x : number
+>p : T
+>x : number
+        }
+    }
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
+module A {
+>A : typeof A
+
+    // not a collision, since we don't export
+    var Origin: string = "0,0";
+>Origin : string
+
+    export module Utils {
+>Utils : typeof Utils
+
+        export class Plane {
+>Plane : Plane
+
+            constructor(public tl: Point, public br: Point) { }
+>tl : Point
+>Point : Point
+>br : Point
+>Point : Point
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/part3.ts ===
+// test the merging actually worked
+
+var o: { x: number; y: number };
+>o : { x: number; y: number; }
+>x : number
+>y : number
+
+var o: A.Point;
+>o : { x: number; y: number; }
+>A : A
+>Point : Point
+
+var o = A.Origin;
+>o : { x: number; y: number; }
+>A.Origin : Point
+>A : typeof A
+>Origin : Point
+
+var o = A.Utils.mirror(o);
+>o : { x: number; y: number; }
+>A.Utils.mirror(o) : { x: number; y: number; }
+>A.Utils.mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>A.Utils : typeof Utils
+>A : typeof A
+>Utils : typeof Utils
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>o : { x: number; y: number; }
+
+var p: { tl: A.Point; br: A.Point };
+>p : { tl: Point; br: Point; }
+>tl : Point
+>A : A
+>Point : Point
+>br : Point
+>A : A
+>Point : Point
+
+var p: A.Utils.Plane;
+>p : { tl: Point; br: Point; }
+>A : A
+>Utils : Utils
+>Plane : Plane
+
+var p = new A.Utils.Plane(o, { x: 1, y: 1 });
+>p : { tl: Point; br: Point; }
+>new A.Utils.Plane(o, { x: 1, y: 1 }) : Plane
+>A.Utils.Plane : typeof Plane
+>A.Utils : typeof Utils
+>A : typeof A
+>Utils : typeof Utils
+>Plane : typeof Plane
+>o : { x: number; y: number; }
+>{ x: 1, y: 1 } : { x: number; y: number; }
+>x : number
+>y : number
+
+

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types

@@ -0,0 +1,112 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.ts ===
+module A {
+>A : A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+
+        toCarth(): Point;
+>toCarth : () => Point
+>Point : Point
+    }
+}
+
+module A {
+>A : A
+
+    export interface Point {
+>Point : Point
+
+        fromCarth(): Point;
+>fromCarth : () => Point
+>Point : Point
+    }
+}
+
+// ensure merges as expected
+var p: { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; };
+>p : { x: number; y: number; toCarth(): Point; fromCarth(): Point; }
+>x : number
+>y : number
+>toCarth : () => Point
+>A : A
+>Point : Point
+>fromCarth : () => Point
+>A : A
+>Point : Point
+
+var p: A.Point;
+>p : { x: number; y: number; toCarth(): Point; fromCarth(): Point; }
+>A : A
+>Point : Point
+
+module X.Y.Z {
+>X : X
+>Y : Y
+>Z : Z
+
+    export interface Line {
+>Line : Line
+
+        new (start: A.Point, end: A.Point);
+>start : Point
+>A : A
+>Point : Point
+>end : Point
+>A : A
+>Point : Point
+    }
+}
+
+module X {
+>X : X
+
+    export module Y.Z {
+>Y : Y
+>Z : Z
+
+        export interface Line {
+>Line : Line
+
+            start: A.Point;
+>start : Point
+>A : A
+>Point : Point
+
+            end: A.Point;
+>end : Point
+>A : A
+>Point : Point
+        }
+    }
+}
+
+// ensure merges as expected
+var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.Point); }
+>l : { new (s: Point, e: Point): any; start: Point; end: Point; }
+>start : Point
+>A : A
+>Point : Point
+>end : Point
+>A : A
+>Point : Point
+>s : Point
+>A : A
+>Point : Point
+>e : Point
+>A : A
+>Point : Point
+
+var l: X.Y.Z.Line;
+>l : { new (s: Point, e: Point): any; start: Point; end: Point; }
+>X : X
+>Y : Y
+>Z : Z
+>Line : Line
+

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.types

@@ -0,0 +1,76 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/TwoInternalModulesThatMergeEachWithExportedModulesOfTheSameName.ts ===
+module A.B {
+>A : typeof A
+>B : typeof B
+
+    export var x: number;
+>x : number
+}
+
+module A{ 
+>A : typeof A
+
+    module B {
+>B : typeof B
+
+        export var x: string;
+>x : string
+    }
+}
+
+// ensure the right var decl is exported
+var x: number;
+>x : number
+
+var x = A.B.x;
+>x : number
+>A.B.x : number
+>A.B : typeof B
+>A : typeof A
+>B : typeof B
+>x : number
+
+module X.Y.Z {
+>X : typeof X
+>Y : typeof Y
+>Z : typeof Z
+
+    export class Line {
+>Line : Line
+
+        length: number;
+>length : number
+    }
+}
+
+module X {
+>X : typeof X
+
+    export module Y {
+>Y : typeof Y
+
+        module Z {
+>Z : typeof Z
+
+            export class Line {
+>Line : Line
+
+                name: string;
+>name : string
+            }
+        }
+    }
+}
+
+// make sure merging works as expected
+var l: { length: number };
+>l : { length: number; }
+>length : number
+
+var l: X.Y.Z.Line;
+>l : { length: number; }
+>X : X
+>Y : Y
+>Z : Z
+>Line : Line
+

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types

@@ -0,0 +1,78 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
+module Root {
+>Root : typeof Root
+
+    export module A {
+>A : typeof A
+
+        export interface Point {
+>Point : Point
+
+            x: number;
+>x : number
+
+            y: number;
+>y : number
+        }
+
+        export module Utils {
+>Utils : typeof Utils
+
+            export function mirror<T extends Point>(p: T) {
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>T : T
+>Point : Point
+>p : T
+>T : T
+
+                return { x: p.y, y: p.x };
+>{ x: p.y, y: p.x } : { x: number; y: number; }
+>x : number
+>p.y : number
+>p : T
+>y : number
+>y : number
+>p.x : number
+>p : T
+>x : number
+            }
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
+module otherRoot {
+>otherRoot : typeof otherRoot
+
+    export module A {
+>A : typeof A
+
+        // have to be fully qualified since in different root
+        export var Origin: Root.A.Point = { x: 0, y: 0 };
+>Origin : Point
+>Root : Root
+>A : A
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+        export module Utils {
+>Utils : typeof Utils
+
+            export class Plane {
+>Plane : Plane
+
+                constructor(public tl: Root.A.Point, public br: Root.A.Point) { }
+>tl : Point
+>Root : Root
+>A : A
+>Point : Point
+>br : Point
+>Root : Root
+>A : A
+>Point : Point
+            }
+        }
+    }
+}

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types

@@ -0,0 +1,122 @@
+=== tests/cases/conformance/internalModules/DeclarationMerging/part1.ts ===
+module A {
+>A : typeof A
+
+    export interface Point {
+>Point : Point
+
+        x: number;
+>x : number
+
+        y: number;
+>y : number
+    }
+
+    export module Utils {
+>Utils : typeof Utils
+
+        export function mirror<T extends Point>(p: T) {
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>T : T
+>Point : Point
+>p : T
+>T : T
+
+            return { x: p.y, y: p.x };
+>{ x: p.y, y: p.x } : { x: number; y: number; }
+>x : number
+>p.y : number
+>p : T
+>y : number
+>y : number
+>p.x : number
+>p : T
+>x : number
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
+module A {
+>A : typeof A
+
+    export var Origin: Point = { x: 0, y: 0 };
+>Origin : Point
+>Point : Point
+>{ x: 0, y: 0 } : { x: number; y: number; }
+>x : number
+>y : number
+
+    export module Utils {
+>Utils : typeof Utils
+
+        export class Plane {
+>Plane : Plane
+
+            constructor(public tl: Point, public br: Point) { }
+>tl : Point
+>Point : Point
+>br : Point
+>Point : Point
+        }
+    }
+}
+
+=== tests/cases/conformance/internalModules/DeclarationMerging/part3.ts ===
+// test the merging actually worked
+
+var o: { x: number; y: number };
+>o : { x: number; y: number; }
+>x : number
+>y : number
+
+var o: A.Point;
+>o : { x: number; y: number; }
+>A : A
+>Point : Point
+
+var o = A.Origin;
+>o : { x: number; y: number; }
+>A.Origin : Point
+>A : typeof A
+>Origin : Point
+
+var o = A.Utils.mirror(o);
+>o : { x: number; y: number; }
+>A.Utils.mirror(o) : { x: number; y: number; }
+>A.Utils.mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>A.Utils : typeof Utils
+>A : typeof A
+>Utils : typeof Utils
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
+>o : { x: number; y: number; }
+
+var p: { tl: A.Point; br: A.Point };
+>p : { tl: Point; br: Point; }
+>tl : Point
+>A : A
+>Point : Point
+>br : Point
+>A : A
+>Point : Point
+
+var p: A.Utils.Plane;
+>p : { tl: Point; br: Point; }
+>A : A
+>Utils : Utils
+>Plane : Plane
+
+var p = new A.Utils.Plane(o, { x: 1, y: 1 });
+>p : { tl: Point; br: Point; }
+>new A.Utils.Plane(o, { x: 1, y: 1 }) : Plane
+>A.Utils.Plane : typeof Plane
+>A.Utils : typeof Utils
+>A : typeof A
+>Utils : typeof Utils
+>Plane : typeof Plane
+>o : { x: number; y: number; }
+>{ x: 1, y: 1 } : { x: number; y: number; }
+>x : number
+>y : number
+
+

tests/baselines/reference/acceptableAlias1.types

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/acceptableAlias1.ts ===
+module M {
+>M : typeof M
+
+    export module N {
+>N : N
+    }
+    export import X = N;
+>X : X
+>N : N
+}
+
+import r = M.X;
+>r : r
+>M : typeof M
+>X : X
+

tests/baselines/reference/accessOverriddenBaseClassMember1.types

@@ -0,0 +1,52 @@
+=== tests/cases/compiler/accessOverriddenBaseClassMember1.ts ===
+class Point {
+>Point : Point
+
+    constructor(public x: number, public y: number) { }
+>x : number
+>y : number
+
+    public toString() {
+>toString : () => string
+
+        return "x=" + this.x + " y=" + this.y;
+>"x=" + this.x + " y=" + this.y : string
+>"x=" + this.x + " y=" : string
+>"x=" + this.x : string
+>this.x : number
+>this : Point
+>x : number
+>this.y : number
+>this : Point
+>y : number
+    }
+}
+class ColoredPoint extends Point {
+>ColoredPoint : ColoredPoint
+>Point : Point
+
+    constructor(x: number, y: number, public color: string) {
+>x : number
+>y : number
+>color : string
+
+        super(x, y);
+>super(x, y) : void
+>x : number
+>y : number
+    }
+    public toString() {
+>toString : () => string
+
+        return super.toString() + " color=" + this.color;
+>super.toString() + " color=" + this.color : string
+>super.toString() + " color=" : string
+>super.toString() : string
+>super.toString : () => string
+>toString : () => string
+>this.color : string
+>this : ColoredPoint
+>color : string
+    }
+}
+

tests/baselines/reference/accessorWithES5.types

@@ -0,0 +1,41 @@
+=== tests/cases/conformance/classes/propertyMemberDeclarations/memberAccessorDeclarations/accessorWithES5.ts ===
+
+class C {
+>C : C
+
+    get x() {
+>x : number
+
+        return 1;
+    }
+}
+
+class D {
+>D : D
+
+    set x(v) {
+>x : any
+>v : any
+    }
+}
+
+var x = {
+>x : { a: number; }
+>{
+    get a() { return 1 }
+} : { a: number; }
+
+    get a() { return 1 }
+>a : number
+}
+
+var y = {
+>y : { b: any; }
+>{
+    set b(v) { }
+} : { b: any; }
+
+    set b(v) { }
+>b : any
+>v : any
+}

tests/baselines/reference/addMoreCallSignaturesToBaseSignature.types

@@ -0,0 +1,24 @@
+=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature.ts ===
+interface Foo {
+>Foo : Foo
+
+    (): string;
+}
+
+interface Bar extends Foo {
+>Bar : Bar
+>Foo : Foo
+
+    (key: string): string;
+>key : string
+}
+
+var a: Bar;
+>a : Bar
+>Bar : Bar
+
+var kitty = a();
+>kitty : string
+>a() : string
+>a : Bar
+

tests/baselines/reference/addMoreCallSignaturesToBaseSignature2.types

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/addMoreCallSignaturesToBaseSignature2.ts ===
+interface Foo {
+>Foo : Foo
+
+    (bar:number): string;
+>bar : number
+}
+
+interface Bar extends Foo {
+>Bar : Bar
+>Foo : Foo
+
+    (key: string): string;
+>key : string
+}
+
+var a: Bar;
+>a : Bar
+>Bar : Bar
+
+var kitty = a(1);
+>kitty : string
+>a(1) : string
+>a : Bar
+

tests/baselines/reference/additionOperatorWithAnyAndEveryType.types

@@ -0,0 +1,168 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithAnyAndEveryType.ts ===
+function foo() { }
+>foo : () => void
+
+class C {
+>C : C
+
+    public a: string;
+>a : string
+
+    static foo() { }
+>foo : () => void
+}
+enum E { a, b, c }
+>E : E
+>a : E
+>b : E
+>c : E
+
+module M { export var a }
+>M : typeof M
+>a : any
+
+var a: any;
+>a : any
+
+var b: boolean;
+>b : boolean
+
+var c: number;
+>c : number
+
+var d: string;
+>d : string
+
+var e: Object;
+>e : Object
+>Object : Object
+
+// any as left operand, result is type Any except plusing string
+var r1 = a + a;
+>r1 : any
+>a + a : any
+>a : any
+>a : any
+
+var r2 = a + b;
+>r2 : any
+>a + b : any
+>a : any
+>b : boolean
+
+var r3 = a + c;
+>r3 : any
+>a + c : any
+>a : any
+>c : number
+
+var r4 = a + d;
+>r4 : string
+>a + d : string
+>a : any
+>d : string
+
+var r5 = a + e;
+>r5 : any
+>a + e : any
+>a : any
+>e : Object
+
+// any as right operand, result is type Any except plusing string
+var r6 = b + a;
+>r6 : any
+>b + a : any
+>b : boolean
+>a : any
+
+var r7 = c + a;
+>r7 : any
+>c + a : any
+>c : number
+>a : any
+
+var r8 = d + a;
+>r8 : string
+>d + a : string
+>d : string
+>a : any
+
+var r9 = e + a;
+>r9 : any
+>e + a : any
+>e : Object
+>a : any
+
+// other cases
+var r10 = a + foo;
+>r10 : any
+>a + foo : any
+>a : any
+>foo : () => void
+
+var r11 = a + foo();
+>r11 : any
+>a + foo() : any
+>a : any
+>foo() : void
+>foo : () => void
+
+var r12 = a + C;
+>r12 : any
+>a + C : any
+>a : any
+>C : typeof C
+
+var r13 = a + new C();
+>r13 : any
+>a + new C() : any
+>a : any
+>new C() : C
+>C : typeof C
+
+var r14 = a + E;
+>r14 : any
+>a + E : any
+>a : any
+>E : typeof E
+
+var r15 = a + E.a;
+>r15 : any
+>a + E.a : any
+>a : any
+>E.a : E
+>E : typeof E
+>a : E
+
+var r16 = a + M;
+>r16 : any
+>a + M : any
+>a : any
+>M : typeof M
+
+var r17 = a + '';
+>r17 : string
+>a + '' : string
+>a : any
+
+var r18 = a + 123;
+>r18 : any
+>a + 123 : any
+>a : any
+
+var r19 = a + { a: '' };
+>r19 : any
+>a + { a: '' } : any
+>a : any
+>{ a: '' } : { a: string; }
+>a : string
+
+var r20 = a + ((a: string) => { return a });
+>r20 : any
+>a + ((a: string) => { return a }) : any
+>a : any
+>((a: string) => { return a }) : (a: string) => string
+>(a: string) => { return a } : (a: string) => string
+>a : string
+>a : string
+

tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types

@@ -0,0 +1,107 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndValidOperator.ts ===
+// If one operand is the null or undefined value, it is treated as having the type of the other operand.
+
+enum E { a, b, c }
+>E : E
+>a : E
+>b : E
+>c : E
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+var c: E;
+>c : E
+>E : E
+
+var d: string;
+>d : string
+
+// null + any
+var r1: any = null + a;
+>r1 : any
+>null + a : any
+>a : any
+
+var r2: any = a + null;
+>r2 : any
+>a + null : any
+>a : any
+
+// null + number/enum
+var r3 = null + b;
+>r3 : number
+>null + b : number
+>b : number
+
+var r4 = null + 1;
+>r4 : number
+>null + 1 : number
+
+var r5 = null + c;
+>r5 : number
+>null + c : number
+>c : E
+
+var r6 = null + E.a;
+>r6 : number
+>null + E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var r7 = null + E['a'];
+>r7 : number
+>null + E['a'] : number
+>E['a'] : E
+>E : typeof E
+
+var r8 = b + null;
+>r8 : number
+>b + null : number
+>b : number
+
+var r9 = 1 + null;
+>r9 : number
+>1 + null : number
+
+var r10 = c + null
+>r10 : number
+>c + null : number
+>c : E
+
+var r11 = E.a + null;
+>r11 : number
+>E.a + null : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var r12 = E['a'] + null;
+>r12 : number
+>E['a'] + null : number
+>E['a'] : E
+>E : typeof E
+
+// null + string
+var r13 = null + d;
+>r13 : string
+>null + d : string
+>d : string
+
+var r14 = null + '';
+>r14 : string
+>null + '' : string
+
+var r15 = d + null;
+>r15 : string
+>d + null : string
+>d : string
+
+var r16 = '' + null;
+>r16 : string
+>'' + null : string
+

tests/baselines/reference/additionOperatorWithNumberAndEnum.types

@@ -0,0 +1,67 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNumberAndEnum.ts ===
+enum E { a, b }
+>E : E
+>a : E
+>b : E
+
+var a: number;
+>a : number
+
+var b: E;
+>b : E
+>E : E
+
+var r1 = a + a;
+>r1 : number
+>a + a : number
+>a : number
+>a : number
+
+var r2 = a + b;
+>r2 : number
+>a + b : number
+>a : number
+>b : E
+
+var r3 = b + a;
+>r3 : number
+>b + a : number
+>b : E
+>a : number
+
+var r4 = b + b;
+>r4 : number
+>b + b : number
+>b : E
+>b : E
+
+var r5 = 0 + a;
+>r5 : number
+>0 + a : number
+>a : number
+
+var r6 = E.a + 0;
+>r6 : number
+>E.a + 0 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var r7 = E.a + E.b;
+>r7 : number
+>E.a + E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var r8 = E['a'] + E['b'];
+>r8 : number
+>E['a'] + E['b'] : number
+>E['a'] : E
+>E : typeof E
+>E['b'] : E
+>E : typeof E
+

tests/baselines/reference/additionOperatorWithStringAndEveryType.types

@@ -0,0 +1,158 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithStringAndEveryType.ts ===
+enum E { a, b, c }
+>E : E
+>a : E
+>b : E
+>c : E
+
+var a: any;
+>a : any
+
+var b: boolean;
+>b : boolean
+
+var c: number;
+>c : number
+
+var d: string;
+>d : string
+
+var e: Object;
+>e : Object
+>Object : Object
+
+var f: void;
+>f : void
+
+var g: E;
+>g : E
+>E : E
+
+var x: string;
+>x : string
+
+// string could plus every type, and the result is always string
+// string as left operand
+var r1 = x + a;
+>r1 : string
+>x + a : string
+>x : string
+>a : any
+
+var r2 = x + b;
+>r2 : string
+>x + b : string
+>x : string
+>b : boolean
+
+var r3 = x + c;
+>r3 : string
+>x + c : string
+>x : string
+>c : number
+
+var r4 = x + d;
+>r4 : string
+>x + d : string
+>x : string
+>d : string
+
+var r5 = x + e;
+>r5 : string
+>x + e : string
+>x : string
+>e : Object
+
+var r6 = x + f;
+>r6 : string
+>x + f : string
+>x : string
+>f : void
+
+var r7 = x + g;
+>r7 : string
+>x + g : string
+>x : string
+>g : E
+
+// string as right operand
+var r8 = a + x;
+>r8 : string
+>a + x : string
+>a : any
+>x : string
+
+var r9 = b + x;
+>r9 : string
+>b + x : string
+>b : boolean
+>x : string
+
+var r10 = c + x;
+>r10 : string
+>c + x : string
+>c : number
+>x : string
+
+var r11 = d + x;
+>r11 : string
+>d + x : string
+>d : string
+>x : string
+
+var r12 = e + x;
+>r12 : string
+>e + x : string
+>e : Object
+>x : string
+
+var r13 = f + x;
+>r13 : string
+>f + x : string
+>f : void
+>x : string
+
+var r14 = g + x;
+>r14 : string
+>g + x : string
+>g : E
+>x : string
+
+// other cases
+var r15 = x + E;
+>r15 : string
+>x + E : string
+>x : string
+>E : typeof E
+
+var r16 = x + E.a;
+>r16 : string
+>x + E.a : string
+>x : string
+>E.a : E
+>E : typeof E
+>a : E
+
+var r17 = x + '';
+>r17 : string
+>x + '' : string
+>x : string
+
+var r18 = x + 0;
+>r18 : string
+>x + 0 : string
+>x : string
+
+var r19 = x + { a: '' };
+>r19 : string
+>x + { a: '' } : string
+>x : string
+>{ a: '' } : { a: string; }
+>a : string
+
+var r20 = x + [];
+>r20 : string
+>x + [] : string
+>x : string
+>[] : undefined[]
+

tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types

@@ -0,0 +1,123 @@
+=== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndValidOperator.ts ===
+// If one operand is the null or undefined value, it is treated as having the type of the other operand.
+
+enum E { a, b, c }
+>E : E
+>a : E
+>b : E
+>c : E
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+var c: E;
+>c : E
+>E : E
+
+var d: string;
+>d : string
+
+// undefined + any
+var r1: any = undefined + a;
+>r1 : any
+>undefined + a : any
+>undefined : undefined
+>a : any
+
+var r2: any = a + undefined;
+>r2 : any
+>a + undefined : any
+>a : any
+>undefined : undefined
+
+// undefined + number/enum
+var r3 = undefined + b;
+>r3 : number
+>undefined + b : number
+>undefined : undefined
+>b : number
+
+var r4 = undefined + 1;
+>r4 : number
+>undefined + 1 : number
+>undefined : undefined
+
+var r5 = undefined + c;
+>r5 : number
+>undefined + c : number
+>undefined : undefined
+>c : E
+
+var r6 = undefined + E.a;
+>r6 : number
+>undefined + E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var r7 = undefined + E['a'];
+>r7 : number
+>undefined + E['a'] : number
+>undefined : undefined
+>E['a'] : E
+>E : typeof E
+
+var r8 = b + undefined;
+>r8 : number
+>b + undefined : number
+>b : number
+>undefined : undefined
+
+var r9 = 1 + undefined;
+>r9 : number
+>1 + undefined : number
+>undefined : undefined
+
+var r10 = c + undefined
+>r10 : number
+>c + undefined : number
+>c : E
+>undefined : undefined
+
+var r11 = E.a + undefined;
+>r11 : number
+>E.a + undefined : number
+>E.a : E
+>E : typeof E
+>a : E
+>undefined : undefined
+
+var r12 = E['a'] + undefined;
+>r12 : number
+>E['a'] + undefined : number
+>E['a'] : E
+>E : typeof E
+>undefined : undefined
+
+// undefined + string
+var r13 = undefined + d;
+>r13 : string
+>undefined + d : string
+>undefined : undefined
+>d : string
+
+var r14 = undefined + '';
+>r14 : string
+>undefined + '' : string
+>undefined : undefined
+
+var r15 = d + undefined;
+>r15 : string
+>d + undefined : string
+>d : string
+>undefined : undefined
+
+var r16 = '' + undefined;
+>r16 : string
+>'' + undefined : string
+>undefined : undefined
+

tests/baselines/reference/aliasUsageInAccessorsOfClass.types

@@ -0,0 +1,60 @@
+=== tests/cases/compiler/aliasUsage1_main.ts ===
+import Backbone = require("aliasUsage1_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsage1_backbone"
+
+import moduleA = require("aliasUsage1_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsage1_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsage1_backbone"
+>Model : typeof Model
+}
+class C2 {
+>C2 : C2
+
+    x: IHasVisualizationModel;
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+
+    get A() {
+>A : IHasVisualizationModel
+
+        return this.x;
+>this.x : IHasVisualizationModel
+>this : C2
+>x : IHasVisualizationModel
+    }
+    set A(x) {
+>A : IHasVisualizationModel
+>x : IHasVisualizationModel
+
+        x = moduleA;
+>x = moduleA : typeof "tests/cases/compiler/aliasUsage1_moduleA"
+>x : IHasVisualizationModel
+>moduleA : typeof "tests/cases/compiler/aliasUsage1_moduleA"
+    }
+}
+=== tests/cases/compiler/aliasUsage1_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsage1_moduleA.ts ===
+import Backbone = require("aliasUsage1_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsage1_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInArray.types

@@ -0,0 +1,48 @@
+=== tests/cases/compiler/aliasUsageInArray_main.ts ===
+import Backbone = require("aliasUsageInArray_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
+
+import moduleA = require("aliasUsageInArray_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
+>Model : typeof Model
+}
+
+var xs: IHasVisualizationModel[] = [moduleA];
+>xs : IHasVisualizationModel[]
+>IHasVisualizationModel : IHasVisualizationModel
+>[moduleA] : IHasVisualizationModel[]
+>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
+
+var xs2: typeof moduleA[] = [moduleA];
+>xs2 : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"[]
+>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
+>[moduleA] : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"[]
+>moduleA : typeof "tests/cases/compiler/aliasUsageInArray_moduleA"
+
+=== tests/cases/compiler/aliasUsageInArray_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInArray_moduleA.ts ===
+import Backbone = require("aliasUsageInArray_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInArray_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInFunctionExpression.types

@@ -0,0 +1,49 @@
+=== tests/cases/compiler/aliasUsageInFunctionExpression_main.ts ===
+import Backbone = require("aliasUsageInFunctionExpression_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
+
+import moduleA = require("aliasUsageInFunctionExpression_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
+>Model : typeof Model
+}
+var f = (x: IHasVisualizationModel) => x;
+>f : (x: IHasVisualizationModel) => IHasVisualizationModel
+>(x: IHasVisualizationModel) => x : (x: IHasVisualizationModel) => IHasVisualizationModel
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>x : IHasVisualizationModel
+
+f = (x) => moduleA;
+>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
+>f : (x: IHasVisualizationModel) => IHasVisualizationModel
+>(x) => moduleA : (x: IHasVisualizationModel) => typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
+>x : IHasVisualizationModel
+>moduleA : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_moduleA"
+
+=== tests/cases/compiler/aliasUsageInFunctionExpression_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInFunctionExpression_moduleA.ts ===
+import Backbone = require("aliasUsageInFunctionExpression_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInFunctionExpression_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInGenericFunction.types

@@ -0,0 +1,63 @@
+=== tests/cases/compiler/aliasUsageInGenericFunction_main.ts ===
+import Backbone = require("aliasUsageInGenericFunction_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
+
+import moduleA = require("aliasUsageInGenericFunction_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
+>Model : typeof Model
+}
+function foo<T extends { a: IHasVisualizationModel }>(x: T) {
+>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
+>T : T
+>a : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>x : T
+>T : T
+
+    return x;
+>x : T
+}
+var r = foo({ a: moduleA });
+>r : { a: typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"; }
+>foo({ a: moduleA }) : { a: typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"; }
+>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
+>{ a: moduleA } : { a: typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"; }
+>a : typeof "tests/cases/compiler/aliasUsageInGenericFunction_moduleA"
+>moduleA : moduleA
+
+var r2 = foo({ a: <IHasVisualizationModel>null });
+>r2 : { a: IHasVisualizationModel; }
+>foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
+>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
+>{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
+>a : IHasVisualizationModel
+><IHasVisualizationModel>null : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+
+=== tests/cases/compiler/aliasUsageInGenericFunction_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInGenericFunction_moduleA.ts ===
+import Backbone = require("aliasUsageInGenericFunction_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInGenericFunction_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInIndexerOfClass.types

@@ -0,0 +1,57 @@
+=== tests/cases/compiler/aliasUsageInIndexerOfClass_main.ts ===
+import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_backbone"
+
+import moduleA = require("aliasUsageInIndexerOfClass_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_backbone"
+>Model : typeof Model
+}
+class N {
+>N : N
+
+    [idx: string]: IHasVisualizationModel
+>idx : string
+>IHasVisualizationModel : IHasVisualizationModel
+
+    x = moduleA;
+>x : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
+>moduleA : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
+}
+class N2 {
+>N2 : N2
+
+    [idx: string]: typeof moduleA
+>idx : string
+>moduleA : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA"
+
+    x: IHasVisualizationModel;
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+}
+=== tests/cases/compiler/aliasUsageInIndexerOfClass_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInIndexerOfClass_moduleA.ts ===
+import Backbone = require("aliasUsageInIndexerOfClass_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInIndexerOfClass_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInObjectLiteral.types

@@ -0,0 +1,62 @@
+=== tests/cases/compiler/aliasUsageInObjectLiteral_main.ts ===
+import Backbone = require("aliasUsageInObjectLiteral_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
+
+import moduleA = require("aliasUsageInObjectLiteral_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
+>Model : typeof Model
+}
+var a: { x: typeof moduleA } = { x: moduleA };
+>a : { x: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
+>x : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
+>moduleA : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
+>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
+>x : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
+>moduleA : moduleA
+
+var b: { x: IHasVisualizationModel } = { x: moduleA };
+>b : { x: IHasVisualizationModel; }
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
+>x : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
+>moduleA : moduleA
+
+var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
+>c : { y: { z: IHasVisualizationModel; }; }
+>y : { z: IHasVisualizationModel; }
+>z : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>{ y: { z: moduleA } } : { y: { z: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }; }
+>y : { z: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
+>{ z: moduleA } : { z: typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"; }
+>z : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_moduleA"
+>moduleA : moduleA
+
+=== tests/cases/compiler/aliasUsageInObjectLiteral_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInObjectLiteral_moduleA.ts ===
+import Backbone = require("aliasUsageInObjectLiteral_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInObjectLiteral_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInOrExpression.types

@@ -0,0 +1,83 @@
+=== tests/cases/compiler/aliasUsageInOrExpression_main.ts ===
+import Backbone = require("aliasUsageInOrExpression_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
+
+import moduleA = require("aliasUsageInOrExpression_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
+>Model : typeof Model
+}
+var i: IHasVisualizationModel;
+>i : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+
+var d1 = i || moduleA;
+>d1 : IHasVisualizationModel
+>i || moduleA : IHasVisualizationModel
+>i : IHasVisualizationModel
+>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
+
+var d2: IHasVisualizationModel = i || moduleA;
+>d2 : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>i || moduleA : IHasVisualizationModel
+>i : IHasVisualizationModel
+>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
+
+var d2: IHasVisualizationModel = moduleA || i;
+>d2 : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>moduleA || i : IHasVisualizationModel
+>moduleA : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
+>i : IHasVisualizationModel
+
+var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
+>e : { x: IHasVisualizationModel; }
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+><{ x: IHasVisualizationModel }>null || { x: moduleA } : { x: IHasVisualizationModel; }
+><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"; }
+>x : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
+>moduleA : moduleA
+
+var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
+>f : { x: IHasVisualizationModel; }
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: IHasVisualizationModel; }
+><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
+>x : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+>{ x: moduleA } : { x: typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"; }
+>x : typeof "tests/cases/compiler/aliasUsageInOrExpression_moduleA"
+>moduleA : moduleA
+
+=== tests/cases/compiler/aliasUsageInOrExpression_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInOrExpression_moduleA.ts ===
+import Backbone = require("aliasUsageInOrExpression_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInOrExpression_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types

@@ -0,0 +1,53 @@
+=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_main.ts ===
+import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
+
+import moduleA = require("aliasUsageInTypeArgumentOfExtendsClause_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
+>Model : typeof Model
+}
+class C<T extends IHasVisualizationModel> {
+>C : C<T>
+>T : T
+>IHasVisualizationModel : IHasVisualizationModel
+
+    x: T;
+>x : T
+>T : T
+}
+class D extends C<IHasVisualizationModel> {
+>D : D
+>C : C<T>
+>IHasVisualizationModel : IHasVisualizationModel
+
+    x = moduleA;
+>x : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
+>moduleA : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA"
+}
+=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_moduleA.ts ===
+import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInTypeArgumentOfExtendsClause_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsageInVarAssignment.types

@@ -0,0 +1,44 @@
+=== tests/cases/compiler/aliasUsageInVarAssignment_main.ts ===
+import Backbone = require("aliasUsageInVarAssignment_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
+
+import moduleA = require("aliasUsageInVarAssignment_moduleA");
+>moduleA : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
+
+interface IHasVisualizationModel {
+>IHasVisualizationModel : IHasVisualizationModel
+
+    VisualizationModel: typeof Backbone.Model;
+>VisualizationModel : typeof Model
+>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
+>Model : typeof Model
+}
+var i: IHasVisualizationModel;
+>i : IHasVisualizationModel
+>IHasVisualizationModel : IHasVisualizationModel
+
+var m: typeof moduleA = i;
+>m : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
+>moduleA : typeof "tests/cases/compiler/aliasUsageInVarAssignment_moduleA"
+>i : IHasVisualizationModel
+
+=== tests/cases/compiler/aliasUsageInVarAssignment_backbone.ts ===
+export class Model {
+>Model : Model
+
+    public someData: string;
+>someData : string
+}
+
+=== tests/cases/compiler/aliasUsageInVarAssignment_moduleA.ts ===
+import Backbone = require("aliasUsageInVarAssignment_backbone");
+>Backbone : typeof "tests/cases/compiler/aliasUsageInVarAssignment_backbone"
+
+export class VisualizationModel extends Backbone.Model {
+>VisualizationModel : VisualizationModel
+>Backbone : Backbone
+>Model : Model
+
+    // interesting stuff here
+}
+

tests/baselines/reference/aliasUsedAsNameValue.types

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/aliasUsedAsNameValue_2.ts ===
+///<reference path='aliasUsedAsNameValue_0.ts' />
+///<reference path='aliasUsedAsNameValue_1.ts' />
+import mod = require("aliasUsedAsNameValue_0");
+>mod : typeof "tests/cases/compiler/aliasUsedAsNameValue_0"
+
+import b = require("aliasUsedAsNameValue_1");
+>b : typeof "tests/cases/compiler/aliasUsedAsNameValue_1"
+ 
+export var a = function () {
+>a : () => void
+>function () {
+    //var x = mod.id; // TODO needed hack that mod is loaded
+    b.b(mod);
+} : () => void
+
+    //var x = mod.id; // TODO needed hack that mod is loaded
+    b.b(mod);
+>b.b(mod) : any
+>b.b : (a: any) => any
+>b : typeof "tests/cases/compiler/aliasUsedAsNameValue_1"
+>b : (a: any) => any
+>mod : typeof "tests/cases/compiler/aliasUsedAsNameValue_0"
+}
+
+=== tests/cases/compiler/aliasUsedAsNameValue_0.ts ===
+export var id: number;
+>id : number
+
+=== tests/cases/compiler/aliasUsedAsNameValue_1.ts ===
+export function b(a: any): any { return null; }
+>b : (a: any) => any
+>a : any
+

tests/baselines/reference/ambientClassDeclarationWithExtends.types

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/ambientClassDeclarationWithExtends.ts ===
+declare class A { }
+>A : A
+
+declare class B extends A { }
+>B : B
+>A : A
+

tests/baselines/reference/ambientDeclarations.types

@@ -0,0 +1,168 @@
+=== tests/cases/conformance/ambient/ambientDeclarations.ts ===
+// Ambient variable without type annotation
+declare var n;
+>n : any
+
+// Ambient variable with type annotation
+declare var m: string;
+>m : string
+
+// Ambient function with no type annotations
+declare function fn1();
+>fn1 : () => any
+
+// Ambient function with type annotations
+declare function fn2(n: string): number;
+>fn2 : (n: string) => number
+>n : string
+
+// Ambient function with valid overloads
+declare function fn3(n: string): number;
+>fn3 : (n: string) => number
+>n : string
+
+declare function fn4(n: number, y: number): string;
+>fn4 : (n: number, y: number) => string
+>n : number
+>y : number
+
+// Ambient function with optional parameters
+declare function fn5(x, y?);
+>fn5 : (x: any, y?: any) => any
+>x : any
+>y : any
+
+declare function fn6(e?);
+>fn6 : (e?: any) => any
+>e : any
+
+declare function fn7(x, y?, ...z);
+>fn7 : (x: any, y?: any, ...z: any[]) => any
+>x : any
+>y : any
+>z : any[]
+
+declare function fn8(y?, ...z: number[]);
+>fn8 : (y?: any, ...z: number[]) => any
+>y : any
+>z : number[]
+
+declare function fn9(...q: {}[]);
+>fn9 : (...q: {}[]) => any
+>q : {}[]
+
+declare function fn10<T>(...q: T[]);
+>fn10 : <T>(...q: T[]) => any
+>T : T
+>q : T[]
+>T : T
+
+// Ambient class
+declare class cls {
+>cls : cls
+
+    constructor();
+    method(): cls;
+>method : () => cls
+>cls : cls
+
+    static static(p): number;
+>static : (p: any) => number
+>p : any
+
+    static q;
+>q : any
+
+    private fn();
+>fn : () => any
+
+    private static fns();
+>fns : () => any
+}
+
+// Ambient enum
+declare enum E1 {
+>E1 : E1
+
+    x,
+>x : E1
+
+    y,
+>y : E1
+
+    z
+>z : E1
+}
+
+// Ambient enum with integer literal initializer
+declare enum E2 {
+>E2 : E2
+
+    q,
+>q : E2
+
+    a = 1,
+>a : E2
+
+    b,
+>b : E2
+
+    c = 2,
+>c : E2
+
+    d
+>d : E2
+}
+
+// Ambient enum members are always exported with or without export keyword
+declare enum E3 {
+>E3 : E3
+
+    A
+>A : E3
+}
+declare module E3 {
+>E3 : typeof E3
+
+    var B;
+>B : any
+}
+var x = E3.B;
+>x : any
+>E3.B : any
+>E3 : typeof E3
+>B : any
+
+// Ambient module
+declare module M1 {
+>M1 : typeof M1
+
+    var x;
+>x : any
+
+    function fn(): number;
+>fn : () => number
+}
+
+// Ambient module members are always exported with or without export keyword
+var p = M1.x;
+>p : any
+>M1.x : any
+>M1 : typeof M1
+>x : any
+
+var q = M1.fn();
+>q : number
+>M1.fn() : number
+>M1.fn : () => number
+>M1 : typeof M1
+>fn : () => number
+
+// Ambient external module in the global module
+// Ambient external module with a string literal name that is a top level external module name
+declare module 'external1' {
+    var q;
+>q : any
+}
+
+

tests/baselines/reference/ambientEnumElementInitializer1.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/ambientEnumElementInitializer1.ts ===
+declare enum E {
+>E : E
+
+ e = 3
+>e : E
+}

tests/baselines/reference/ambientEnumElementInitializer2.types

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/ambientEnumElementInitializer2.ts ===
+declare enum E {
+>E : E
+
+ e = -3 // Negative
+>e : E
+>-3 : number
+}

tests/baselines/reference/ambientEnumElementInitializer4.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/ambientEnumElementInitializer4.ts ===
+declare enum E {
+>E : E
+
+ e = 0xA
+>e : E
+}

tests/baselines/reference/ambientEnumElementInitializer5.types

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/ambientEnumElementInitializer5.ts ===
+declare enum E {
+>E : E
+
+ e = -0xA
+>e : E
+>-0xA : number
+}

tests/baselines/reference/ambientEnumElementInitializer6.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/ambientEnumElementInitializer6.ts ===
+declare module M {
+>M : typeof M
+
+    enum E {
+>E : E
+
+        e = 3
+>e : E
+    }
+}

tests/baselines/reference/ambientExternalModuleReopen.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/ambientExternalModuleReopen.ts ===
+declare module "fs" {
+    var x: string;
+>x : string
+}
+declare module 'fs' {
+    var y: number;
+>y : number
+}

tests/baselines/reference/ambientExternalModuleWithInternalImportDeclaration.types

@@ -0,0 +1,33 @@
+=== tests/cases/compiler/ambientExternalModuleWithInternalImportDeclaration_1.ts ===
+///<reference path='ambientExternalModuleWithInternalImportDeclaration_0.ts'/>
+import A = require('M');
+>A : typeof C
+
+var c = new A();
+>c : C
+>new A() : C
+>A : typeof C
+
+=== tests/cases/compiler/ambientExternalModuleWithInternalImportDeclaration_0.ts ===
+declare module 'M' {
+    module C {
+>C : typeof C
+
+        export var f: number;
+>f : number
+    }
+    class C {
+>C : C
+
+        foo(): void;
+>foo : () => void
+    }
+    import X = C;
+>X : typeof C
+>C : C
+
+    export = X;
+>X : C
+
+}
+

tests/baselines/reference/ambientExternalModuleWithoutInternalImportDeclaration.types

@@ -0,0 +1,29 @@
+=== tests/cases/compiler/ambientExternalModuleWithoutInternalImportDeclaration_1.ts ===
+///<reference path='ambientExternalModuleWithoutInternalImportDeclaration_0.ts'/>
+import A = require('M');
+>A : typeof C
+
+var c = new A();
+>c : C
+>new A() : C
+>A : typeof C
+
+=== tests/cases/compiler/ambientExternalModuleWithoutInternalImportDeclaration_0.ts ===
+declare module 'M' {
+    module C {
+>C : typeof C
+
+        export var f: number;
+>f : number
+    }
+    class C {
+>C : C
+
+        foo(): void;
+>foo : () => void
+    }
+    export = C;
+>C : C
+
+}
+

tests/baselines/reference/ambientFundule.types

@@ -0,0 +1,12 @@
+=== tests/cases/compiler/ambientFundule.ts ===
+declare function f();
+>f : typeof f
+
+declare module f { var x }
+>f : typeof f
+>x : any
+
+declare function f(x);
+>f : typeof f
+>x : any
+

tests/baselines/reference/ambientModuleExports.types

@@ -0,0 +1,63 @@
+=== tests/cases/compiler/ambientModuleExports.ts ===
+declare module Foo {
+>Foo : typeof Foo
+
+	function a():void;
+>a : () => void
+
+	var b:number;
+>b : number
+
+	class C {}
+>C : C
+}
+
+Foo.a();
+>Foo.a() : void
+>Foo.a : () => void
+>Foo : typeof Foo
+>a : () => void
+
+Foo.b;
+>Foo.b : number
+>Foo : typeof Foo
+>b : number
+
+var c = new Foo.C();
+>c : C
+>new Foo.C() : C
+>Foo.C : typeof C
+>Foo : typeof Foo
+>C : typeof C
+
+declare module Foo2 {
+>Foo2 : typeof Foo2
+
+    export function a(): void;
+>a : () => void
+
+    export var b: number;
+>b : number
+
+    export class C { }
+>C : C
+}
+
+Foo2.a();
+>Foo2.a() : void
+>Foo2.a : () => void
+>Foo2 : typeof Foo2
+>a : () => void
+
+Foo2.b;
+>Foo2.b : number
+>Foo2 : typeof Foo2
+>b : number
+
+var c2 = new Foo2.C();
+>c2 : C
+>new Foo2.C() : C
+>Foo2.C : typeof C
+>Foo2 : typeof Foo2
+>C : typeof C
+

tests/baselines/reference/ambientModuleWithClassDeclarationWithExtends.types

@@ -0,0 +1,11 @@
+=== tests/cases/compiler/ambientModuleWithClassDeclarationWithExtends.ts ===
+declare module foo {
+>foo : typeof foo
+
+    class A { }
+>A : A
+
+    class B extends A { }
+>B : B
+>A : A
+}

tests/baselines/reference/ambientModules.types

@@ -0,0 +1,14 @@
+=== tests/cases/compiler/ambientModules.ts ===
+declare module Foo.Bar { export var foo; };
+>Foo : typeof Foo
+>Bar : typeof Bar
+>foo : any
+
+Foo.Bar.foo = 5; 
+>Foo.Bar.foo = 5 : number
+>Foo.Bar.foo : any
+>Foo.Bar : typeof Bar
+>Foo : typeof Foo
+>Bar : typeof Bar
+>foo : any
+

tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types

@@ -0,0 +1,78 @@
+=== tests/cases/compiler/ambiguousCallsWhereReturnTypesAgree.ts ===
+class TestClass {
+>TestClass : TestClass
+
+    public bar(x: string): void;
+>bar : { (x: string): void; (x: string[]): void; }
+>x : string
+
+    public bar(x: string[]): void;
+>bar : { (x: string): void; (x: string[]): void; }
+>x : string[]
+
+    public bar(x: any): void {
+>bar : { (x: string): void; (x: string[]): void; }
+>x : any
+        
+    }
+ 
+    public foo(x: string): void;
+>foo : { (x: string): void; (x: string[]): void; }
+>x : string
+
+    public foo(x: string[]): void;
+>foo : { (x: string): void; (x: string[]): void; }
+>x : string[]
+
+    public foo(x: any): void {
+>foo : { (x: string): void; (x: string[]): void; }
+>x : any
+
+        this.bar(x); // should not error
+>this.bar(x) : void
+>this.bar : { (x: string): void; (x: string[]): void; }
+>this : TestClass
+>bar : { (x: string): void; (x: string[]): void; }
+>x : any
+    }
+}
+
+class TestClass2 {
+>TestClass2 : TestClass2
+
+    public bar(x: string): number;
+>bar : { (x: string): number; (x: string[]): number; }
+>x : string
+
+    public bar(x: string[]): number;
+>bar : { (x: string): number; (x: string[]): number; }
+>x : string[]
+
+    public bar(x: any): number {
+>bar : { (x: string): number; (x: string[]): number; }
+>x : any
+
+        return 0;
+    }
+ 
+    public foo(x: string): number;
+>foo : { (x: string): number; (x: string[]): number; }
+>x : string
+
+    public foo(x: string[]): number;
+>foo : { (x: string): number; (x: string[]): number; }
+>x : string[]
+
+    public foo(x: any): number {
+>foo : { (x: string): number; (x: string[]): number; }
+>x : any
+
+        return this.bar(x); // should not error
+>this.bar(x) : number
+>this.bar : { (x: string): number; (x: string[]): number; }
+>this : TestClass2
+>bar : { (x: string): number; (x: string[]): number; }
+>x : any
+    }
+}
+

tests/baselines/reference/ambiguousOverloadResolution.types

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/ambiguousOverloadResolution.ts ===
+class A { }
+>A : A
+
+class B extends A { x: number; }
+>B : B
+>A : A
+>x : number
+
+declare function f(p: A, q: B): number;
+>f : { (p: A, q: B): number; (p: B, q: A): string; }
+>p : A
+>A : A
+>q : B
+>B : B
+
+declare function f(p: B, q: A): string;
+>f : { (p: A, q: B): number; (p: B, q: A): string; }
+>p : B
+>B : B
+>q : A
+>A : A
+
+var x: B;
+>x : B
+>B : B
+
+var t: number = f(x, x); // Not an error
+>t : number
+>f(x, x) : number
+>f : { (p: A, q: B): number; (p: B, q: A): string; }
+>x : B
+>x : B
+

tests/baselines/reference/amdImportAsPrimaryExpression.types

@@ -0,0 +1,25 @@
+=== tests/cases/conformance/externalModules/foo_1.ts ===
+import foo = require("./foo_0");
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
+
+if(foo.E1.A === 0){
+>foo.E1.A === 0 : boolean
+>foo.E1.A : E1
+>foo.E1 : typeof E1
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
+>E1 : typeof E1
+>A : E1
+
+	// Should cause runtime import - interesting optimization possibility, as gets inlined to 0.
+}
+
+=== tests/cases/conformance/externalModules/foo_0.ts ===
+export enum E1 {
+>E1 : E1
+
+	A,B,C
+>A : E1
+>B : E1
+>C : E1
+}
+

tests/baselines/reference/amdImportNotAsPrimaryExpression.types

@@ -0,0 +1,82 @@
+=== tests/cases/conformance/externalModules/foo_1.ts ===
+import foo = require("./foo_0");
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
+
+// None of the below should cause a runtime dependency on foo_0
+import f = foo.M1;
+>f : f
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
+>M1 : M1
+
+var i: f.I2;
+>i : I2
+>f : f
+>I2 : I2
+
+var x: foo.C1 = <{m1: number}>{};
+>x : C1
+>foo : foo
+>C1 : C1
+><{m1: number}>{} : { m1: number; }
+>m1 : number
+>{} : {}
+
+var y: typeof foo.C1.s1 = false;
+>y : boolean
+>foo : typeof "tests/cases/conformance/externalModules/foo_0"
+>C1 : typeof C1
+>s1 : boolean
+
+var z: foo.M1.I2;
+>z : I2
+>foo : foo
+>M1 : M1
+>I2 : I2
+
+var e: number = <foo.E1>0;
+>e : number
+><foo.E1>0 : E1
+>foo : foo
+>E1 : E1
+
+=== tests/cases/conformance/externalModules/foo_0.ts ===
+export class C1 {
+>C1 : C1
+
+	m1 = 42;
+>m1 : number
+
+	static s1 = true;
+>s1 : boolean
+}
+
+export interface I1 {
+>I1 : I1
+
+	name: string;
+>name : string
+
+	age: number;
+>age : number
+}
+
+export module M1 {
+>M1 : M1
+
+	export interface I2 {
+>I2 : I2
+
+		foo: string;
+>foo : string
+	}
+}
+
+export enum E1 {
+>E1 : E1
+
+	A,B,C
+>A : E1
+>B : E1
+>C : E1
+}
+

tests/baselines/reference/anonterface.types

@@ -0,0 +1,41 @@
+=== tests/cases/compiler/anonterface.ts ===
+module M {
+>M : typeof M
+
+    export class C {
+>C : C
+
+        m(fn:{ (n:number):string; },n2:number):string {
+>m : (fn: (n: number) => string, n2: number) => string
+>fn : (n: number) => string
+>n : number
+>n2 : number
+
+            return fn(n2);
+>fn(n2) : string
+>fn : (n: number) => string
+>n2 : number
+        }
+    }
+}
+
+var c=new M.C();
+>c : C
+>new M.C() : C
+>M.C : typeof C
+>M : typeof M
+>C : typeof C
+
+c.m(function(n) { return "hello: "+n; },18);
+>c.m(function(n) { return "hello: "+n; },18) : string
+>c.m : (fn: (n: number) => string, n2: number) => string
+>c : C
+>m : (fn: (n: number) => string, n2: number) => string
+>function(n) { return "hello: "+n; } : (n: number) => string
+>n : number
+>"hello: "+n : string
+>n : number
+
+
+
+

tests/baselines/reference/anyAsFunctionCall.types

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/types/any/anyAsFunctionCall.ts ===
+// any is considered an untyped function call
+// can be called except with type arguments which is an error
+
+var x: any;
+>x : any
+
+var a = x();
+>a : any
+>x() : any
+>x : any
+
+var b = x('hello');
+>b : any
+>x('hello') : any
+>x : any
+
+var c = x(x);
+>c : any
+>x(x) : any
+>x : any
+>x : any
+

tests/baselines/reference/anyAsReturnTypeForNewOnCall.types

@@ -0,0 +1,35 @@
+=== tests/cases/compiler/anyAsReturnTypeForNewOnCall.ts ===
+function Point(x, y) {
+>Point : (x: any, y: any) => void
+>x : any
+>y : any
+
+ this.x = x;
+>this.x = x : any
+>this.x : any
+>this : any
+>x : any
+>x : any
+
+ this.y = y;
+>this.y = y : any
+>this.y : any
+>this : any
+>y : any
+>y : any
+
+}
+
+var o = new Point(3, 4);
+>o : any
+>new Point(3, 4) : any
+>Point : (x: any, y: any) => void
+
+var xx = o.x;
+>xx : any
+>o.x : any
+>o : any
+>x : any
+
+ 
+

tests/baselines/reference/anyAssignabilityInInheritance.types

@@ -0,0 +1,321 @@
+=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/anyAssignabilityInInheritance.ts ===
+// any is not a subtype of any other types, errors expected on all the below derived classes unless otherwise noted
+
+interface I {
+>I : I
+
+    [x: string]: any;
+>x : string
+
+    foo: any; // ok, any identical to itself
+>foo : any
+}
+
+var a: any;
+>a : any
+
+declare function foo2(x: number): number;
+>foo2 : { (x: number): number; (x: any): any; }
+>x : number
+
+declare function foo2(x: any): any;
+>foo2 : { (x: number): number; (x: any): any; }
+>x : any
+
+var r3 = foo2(a); // any, not a subtype of number so it skips that overload, is a subtype of itself so it picks second (if truly ambiguous it would pick first overload)
+>r3 : any
+>foo2(a) : any
+>foo2 : { (x: number): number; (x: any): any; }
+>a : any
+
+declare function foo3(x: string): string;
+>foo3 : { (x: string): string; (x: any): any; }
+>x : string
+
+declare function foo3(x: any): any;
+>foo3 : { (x: string): string; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo4(x: boolean): boolean;
+>foo4 : { (x: boolean): boolean; (x: any): any; }
+>x : boolean
+
+declare function foo4(x: any): any;
+>foo4 : { (x: boolean): boolean; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo5(x: Date): Date;
+>foo5 : { (x: Date): Date; (x: any): any; }
+>x : Date
+>Date : Date
+>Date : Date
+
+declare function foo5(x: any): any;
+>foo5 : { (x: Date): Date; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo6(x: RegExp): RegExp;
+>foo6 : { (x: RegExp): RegExp; (x: any): any; }
+>x : RegExp
+>RegExp : RegExp
+>RegExp : RegExp
+
+declare function foo6(x: any): any;
+>foo6 : { (x: RegExp): RegExp; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo7(x: { bar: number }): { bar: number };
+>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
+>x : { bar: number; }
+>bar : number
+>bar : number
+
+declare function foo7(x: any): any;
+>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo8(x: number[]): number[];
+>foo8 : { (x: number[]): number[]; (x: any): any; }
+>x : number[]
+
+declare function foo8(x: any): any;
+>foo8 : { (x: number[]): number[]; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+interface I8 { foo: string }
+>I8 : I8
+>foo : string
+
+declare function foo9(x: I8): I8;
+>foo9 : { (x: I8): I8; (x: any): any; }
+>x : I8
+>I8 : I8
+>I8 : I8
+
+declare function foo9(x: any): any;
+>foo9 : { (x: I8): I8; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+class A { foo: number; }
+>A : A
+>foo : number
+
+declare function foo10(x: A): A;
+>foo10 : { (x: A): A; (x: any): any; }
+>x : A
+>A : A
+>A : A
+
+declare function foo10(x: any): any;
+>foo10 : { (x: A): A; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+class A2<T> { foo: T; }
+>A2 : A2<T>
+>T : T
+>foo : T
+>T : T
+
+declare function foo11(x: A2<string>): A2<string>;
+>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
+>x : A2<string>
+>A2 : A2<T>
+>A2 : A2<T>
+
+declare function foo11(x: any): any;
+>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo12(x: (x) => number): (x) => number;
+>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
+>x : (x: any) => number
+>x : any
+>x : any
+
+declare function foo12(x: any): any;
+>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
+>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
+>x : <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+>T : T
+>x : T
+>T : T
+>T : T
+
+declare function foo13(x: any): any;
+>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+enum E { A }
+>E : E
+>A : E
+
+declare function foo14(x: E): E;
+>foo14 : { (x: E): E; (x: any): any; }
+>x : E
+>E : E
+>E : E
+
+declare function foo14(x: any): any;
+>foo14 : { (x: E): E; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+function f() { }
+>f : typeof f
+
+module f {
+>f : typeof f
+
+    export var bar = 1;
+>bar : number
+}
+declare function foo15(x: typeof f): typeof f;
+>foo15 : { (x: typeof f): typeof f; (x: any): any; }
+>x : typeof f
+>f : typeof f
+>f : typeof f
+
+declare function foo15(x: any): any;
+>foo15 : { (x: typeof f): typeof f; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+class CC { baz: string }
+>CC : CC
+>baz : string
+
+module CC {
+>CC : typeof CC
+
+    export var bar = 1;
+>bar : number
+}
+declare function foo16(x: CC): CC;
+>foo16 : { (x: CC): CC; (x: any): any; }
+>x : CC
+>CC : CC
+>CC : CC
+
+declare function foo16(x: any): any;
+>foo16 : { (x: CC): CC; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo17(x: Object): Object;
+>foo17 : { (x: Object): Object; (x: any): any; }
+>x : Object
+>Object : Object
+>Object : Object
+
+declare function foo17(x: any): any;
+>foo17 : { (x: Object): Object; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+
+declare function foo18(x: {}): {};
+>foo18 : { (x: {}): {}; (x: any): any; }
+>x : {}
+
+declare function foo18(x: any): any;
+>foo18 : { (x: {}): {}; (x: any): any; }
+>x : any
+
+var r3 = foo3(a); // any
+>r3 : any
+>foo3(a) : any
+>foo3 : { (x: string): string; (x: any): any; }
+>a : any
+

tests/baselines/reference/anyAssignableToEveryType.types

@@ -0,0 +1,156 @@
+=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/anyAssignableToEveryType.ts ===
+var a: any;
+>a : any
+
+class C {
+>C : C
+
+    foo: string;
+>foo : string
+}
+var ac: C;
+>ac : C
+>C : C
+
+interface I {
+>I : I
+
+    foo: string;
+>foo : string
+}
+var ai: I;
+>ai : I
+>I : I
+
+enum E { A }
+>E : E
+>A : E
+
+var ae: E;
+>ae : E
+>E : E
+
+var b: number = a;
+>b : number
+>a : any
+
+var c: string = a;
+>c : string
+>a : any
+
+var d: boolean = a;
+>d : boolean
+>a : any
+
+var e: Date = a;
+>e : Date
+>Date : Date
+>a : any
+
+var f: any = a;
+>f : any
+>a : any
+
+var g: void = a;
+>g : void
+>a : any
+
+var h: Object = a;
+>h : Object
+>Object : Object
+>a : any
+
+var i: {} = a;
+>i : {}
+>a : any
+
+var j: () => {} = a;
+>j : () => {}
+>a : any
+
+var k: Function = a;
+>k : Function
+>Function : Function
+>a : any
+
+var l: (x: number) => string = a;
+>l : (x: number) => string
+>x : number
+>a : any
+
+ac = a;
+>ac = a : any
+>ac : C
+>a : any
+
+ai = a;
+>ai = a : any
+>ai : I
+>a : any
+
+ae = a;
+>ae = a : any
+>ae : E
+>a : any
+
+var m: number[] = a;
+>m : number[]
+>a : any
+
+var n: { foo: string } = a;
+>n : { foo: string; }
+>foo : string
+>a : any
+
+var o: <T>(x: T) => T = a;
+>o : <T>(x: T) => T
+>T : T
+>x : T
+>T : T
+>T : T
+>a : any
+
+var p: Number = a;
+>p : Number
+>Number : Number
+>a : any
+
+var q: String = a;
+>q : String
+>String : String
+>a : any
+
+function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
+>foo : <T, U, V extends Date>(x: T, y: U, z: V) => void
+>T : T
+>U : U
+>V : V
+>Date : Date
+>x : T
+>T : T
+>y : U
+>U : U
+>z : V
+>V : V
+
+    x = a;
+>x = a : any
+>x : T
+>a : any
+
+    y = a;
+>y = a : any
+>y : U
+>a : any
+
+    z = a;
+>z = a : any
+>z : V
+>a : any
+}
+
+//function foo<T, U extends T, V extends Date>(x: T, y: U, z: V) {
+//    x = a;
+//    y = a;
+//    z = a;
+//}

tests/baselines/reference/anyInferenceAnonymousFunctions.types

@@ -0,0 +1,93 @@
+=== tests/cases/compiler/anyInferenceAnonymousFunctions.ts ===
+var paired: any[];
+>paired : any[]
+
+paired.reduce(function (a1, a2) {
+>paired.reduce(function (a1, a2) {
+
+    return a1.concat({});
+
+} , []) : any
+>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired : any[]
+>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>function (a1, a2) {
+
+    return a1.concat({});
+
+} : (a1: any, a2: any) => any
+>a1 : any
+>a2 : any
+
+    return a1.concat({});
+>a1.concat({}) : any
+>a1.concat : any
+>a1 : any
+>concat : any
+>{} : {}
+
+} , []);
+>[] : undefined[]
+
+paired.reduce((b1, b2) => {
+>paired.reduce((b1, b2) => {
+
+    return b1.concat({});
+} , []) : any
+>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired : any[]
+>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>(b1, b2) => {
+
+    return b1.concat({});
+} : (b1: any, b2: any) => any
+>b1 : any
+>b2 : any
+
+    return b1.concat({});
+>b1.concat({}) : any
+>b1.concat : any
+>b1 : any
+>concat : any
+>{} : {}
+
+} , []);
+>[] : undefined[]
+
+paired.reduce((b3, b4) => b3.concat({}), []);
+>paired.reduce((b3, b4) => b3.concat({}), []) : any
+>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>paired : any[]
+>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
+>(b3, b4) => b3.concat({}) : (b3: any, b4: any) => any
+>b3 : any
+>b4 : any
+>b3.concat({}) : any
+>b3.concat : any
+>b3 : any
+>concat : any
+>{} : {}
+>[] : undefined[]
+
+paired.map((c1) => c1.count);
+>paired.map((c1) => c1.count) : any[]
+>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>paired : any[]
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>(c1) => c1.count : (c1: any) => any
+>c1 : any
+>c1.count : any
+>c1 : any
+>count : any
+
+paired.map(function (c2) { return c2.count; });
+>paired.map(function (c2) { return c2.count; }) : any[]
+>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>paired : any[]
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>function (c2) { return c2.count; } : (c2: any) => any
+>c2 : any
+>c2.count : any
+>c2 : any
+>count : any
+

tests/baselines/reference/anyIsAssignableToObject.types

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/anyIsAssignableToObject.ts ===
+interface P {
+>P : P
+
+    p: {};
+>p : {}
+}
+
+interface Q extends P { // Check assignability here. Any is assignable to {}
+>Q : Q
+>P : P
+
+    p: any;
+>p : any
+}

tests/baselines/reference/anyIsAssignableToVoid.types

@@ -0,0 +1,15 @@
+=== tests/cases/compiler/anyIsAssignableToVoid.ts ===
+interface P {
+>P : P
+
+    p: void;
+>p : void
+}
+
+interface Q extends P { // check assignability here. any is assignable to void.
+>Q : Q
+>P : P
+
+    p: any;
+>p : any
+}

tests/baselines/reference/anyPlusAny1.types

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/anyPlusAny1.ts ===
+var x;
+>x : any
+
+x.name = "hello";
+>x.name = "hello" : string
+>x.name : any
+>x : any
+>name : any
+
+var z = x + x;
+>z : any
+>x + x : any
+>x : any
+>x : any
+

tests/baselines/reference/anyPropertyAccess.types

@@ -0,0 +1,43 @@
+=== tests/cases/conformance/types/any/anyPropertyAccess.ts ===
+var x: any;
+>x : any
+
+var a = x.foo;
+>a : any
+>x.foo : any
+>x : any
+>foo : any
+
+var b = x['foo'];
+>b : any
+>x['foo'] : any
+>x : any
+
+var c = x['fn']();
+>c : any
+>x['fn']() : any
+>x['fn'] : any
+>x : any
+
+var d = x.bar.baz;
+>d : any
+>x.bar.baz : any
+>x.bar : any
+>x : any
+>bar : any
+>baz : any
+
+var e = x[0].foo;
+>e : any
+>x[0].foo : any
+>x[0] : any
+>x : any
+>foo : any
+
+var f = x['0'].bar;
+>f : any
+>x['0'].bar : any
+>x['0'] : any
+>x : any
+>bar : any
+

tests/baselines/reference/argsInScope.types

@@ -0,0 +1,36 @@
+=== tests/cases/compiler/argsInScope.ts ===
+class C {
+>C : C
+
+    P(ii:number, j:number, k:number) {
+>P : (ii: number, j: number, k: number) => void
+>ii : number
+>j : number
+>k : number
+
+       for (var i = 0; i < arguments.length; i++) {
+>i : number
+>i < arguments.length : boolean
+>i : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+>i++ : number
+>i : number
+
+           // WScript.Echo("param: " + arguments[i]);
+       }
+    }
+}
+
+var c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+
+c.P(1,2,3);
+>c.P(1,2,3) : void
+>c.P : (ii: number, j: number, k: number) => void
+>c : C
+>P : (ii: number, j: number, k: number) => void
+

tests/baselines/reference/arguments.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/arguments.ts ===
+function f() {
+>f : () => void
+
+    var x=arguments[12];
+>x : any
+>arguments[12] : any
+>arguments : IArguments
+}

tests/baselines/reference/argumentsUsedInObjectLiteralProperty.types

@@ -0,0 +1,23 @@
+=== tests/cases/compiler/argumentsUsedInObjectLiteralProperty.ts ===
+class A {
+>A : A
+
+    public static createSelectableViewModel(initialState?: any, selectedValue?: any) {
+>createSelectableViewModel : (initialState?: any, selectedValue?: any) => { selectedValue: number; }
+>initialState : any
+>selectedValue : any
+
+        return {
+>{
+            selectedValue: arguments.length
+        } : { selectedValue: number; }
+
+            selectedValue: arguments.length
+>selectedValue : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        };
+    }
+}

tests/baselines/reference/arithmeticOperatorWithAnyAndNumber.types

@@ -0,0 +1,437 @@
+=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithAnyAndNumber.ts ===
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+// operator *
+var ra1 = a * a;
+>ra1 : number
+>a * a : number
+>a : any
+>a : any
+
+var ra2 = a * b;
+>ra2 : number
+>a * b : number
+>a : any
+>b : number
+
+var ra3 = a * 0;
+>ra3 : number
+>a * 0 : number
+>a : any
+
+var ra4 = 0 * a;
+>ra4 : number
+>0 * a : number
+>a : any
+
+var ra5 = 0 * 0;
+>ra5 : number
+>0 * 0 : number
+
+var ra6 = b * 0;
+>ra6 : number
+>b * 0 : number
+>b : number
+
+var ra7 = 0 * b;
+>ra7 : number
+>0 * b : number
+>b : number
+
+var ra8 = b * b;
+>ra8 : number
+>b * b : number
+>b : number
+>b : number
+
+// operator /
+var rb1 = a / a;
+>rb1 : number
+>a / a : number
+>a : any
+>a : any
+
+var rb2 = a / b;
+>rb2 : number
+>a / b : number
+>a : any
+>b : number
+
+var rb3 = a / 0;
+>rb3 : number
+>a / 0 : number
+>a : any
+
+var rb4 = 0 / a;
+>rb4 : number
+>0 / a : number
+>a : any
+
+var rb5 = 0 / 0;
+>rb5 : number
+>0 / 0 : number
+
+var rb6 = b / 0;
+>rb6 : number
+>b / 0 : number
+>b : number
+
+var rb7 = 0 / b;
+>rb7 : number
+>0 / b : number
+>b : number
+
+var rb8 = b / b;
+>rb8 : number
+>b / b : number
+>b : number
+>b : number
+
+// operator %
+var rc1 = a % a;
+>rc1 : number
+>a % a : number
+>a : any
+>a : any
+
+var rc2 = a % b;
+>rc2 : number
+>a % b : number
+>a : any
+>b : number
+
+var rc3 = a % 0;
+>rc3 : number
+>a % 0 : number
+>a : any
+
+var rc4 = 0 % a;
+>rc4 : number
+>0 % a : number
+>a : any
+
+var rc5 = 0 % 0;
+>rc5 : number
+>0 % 0 : number
+
+var rc6 = b % 0;
+>rc6 : number
+>b % 0 : number
+>b : number
+
+var rc7 = 0 % b;
+>rc7 : number
+>0 % b : number
+>b : number
+
+var rc8 = b % b;
+>rc8 : number
+>b % b : number
+>b : number
+>b : number
+
+// operator -
+var rd1 = a - a;
+>rd1 : number
+>a - a : number
+>a : any
+>a : any
+
+var rd2 = a - b;
+>rd2 : number
+>a - b : number
+>a : any
+>b : number
+
+var rd3 = a - 0;
+>rd3 : number
+>a - 0 : number
+>a : any
+
+var rd4 = 0 - a;
+>rd4 : number
+>0 - a : number
+>a : any
+
+var rd5 = 0 - 0;
+>rd5 : number
+>0 - 0 : number
+
+var rd6 = b - 0;
+>rd6 : number
+>b - 0 : number
+>b : number
+
+var rd7 = 0 - b;
+>rd7 : number
+>0 - b : number
+>b : number
+
+var rd8 = b - b;
+>rd8 : number
+>b - b : number
+>b : number
+>b : number
+
+// operator <<
+var re1 = a << a;
+>re1 : number
+>a << a : number
+>a : any
+>a : any
+
+var re2 = a << b;
+>re2 : number
+>a << b : number
+>a : any
+>b : number
+
+var re3 = a << 0;
+>re3 : number
+>a << 0 : number
+>a : any
+
+var re4 = 0 << a;
+>re4 : number
+>0 << a : number
+>a : any
+
+var re5 = 0 << 0;
+>re5 : number
+>0 << 0 : number
+
+var re6 = b << 0;
+>re6 : number
+>b << 0 : number
+>b : number
+
+var re7 = 0 << b;
+>re7 : number
+>0 << b : number
+>b : number
+
+var re8 = b << b;
+>re8 : number
+>b << b : number
+>b : number
+>b : number
+
+// operator >>
+var rf1 = a >> a;
+>rf1 : number
+>a >> a : number
+>a : any
+>a : any
+
+var rf2 = a >> b;
+>rf2 : number
+>a >> b : number
+>a : any
+>b : number
+
+var rf3 = a >> 0;
+>rf3 : number
+>a >> 0 : number
+>a : any
+
+var rf4 = 0 >> a;
+>rf4 : number
+>0 >> a : number
+>a : any
+
+var rf5 = 0 >> 0;
+>rf5 : number
+>0 >> 0 : number
+
+var rf6 = b >> 0;
+>rf6 : number
+>b >> 0 : number
+>b : number
+
+var rf7 = 0 >> b;
+>rf7 : number
+>0 >> b : number
+>b : number
+
+var rf8 = b >> b;
+>rf8 : number
+>b >> b : number
+>b : number
+>b : number
+
+// operator >>>
+var rg1 = a >>> a;
+>rg1 : number
+>a >>> a : number
+>a : any
+>a : any
+
+var rg2 = a >>> b;
+>rg2 : number
+>a >>> b : number
+>a : any
+>b : number
+
+var rg3 = a >>> 0;
+>rg3 : number
+>a >>> 0 : number
+>a : any
+
+var rg4 = 0 >>> a;
+>rg4 : number
+>0 >>> a : number
+>a : any
+
+var rg5 = 0 >>> 0;
+>rg5 : number
+>0 >>> 0 : number
+
+var rg6 = b >>> 0;
+>rg6 : number
+>b >>> 0 : number
+>b : number
+
+var rg7 = 0 >>> b;
+>rg7 : number
+>0 >>> b : number
+>b : number
+
+var rg8 = b >>> b;
+>rg8 : number
+>b >>> b : number
+>b : number
+>b : number
+
+// operator &
+var rh1 = a & a;
+>rh1 : number
+>a & a : number
+>a : any
+>a : any
+
+var rh2 = a & b;
+>rh2 : number
+>a & b : number
+>a : any
+>b : number
+
+var rh3 = a & 0;
+>rh3 : number
+>a & 0 : number
+>a : any
+
+var rh4 = 0 & a;
+>rh4 : number
+>0 & a : number
+>a : any
+
+var rh5 = 0 & 0;
+>rh5 : number
+>0 & 0 : number
+
+var rh6 = b & 0;
+>rh6 : number
+>b & 0 : number
+>b : number
+
+var rh7 = 0 & b;
+>rh7 : number
+>0 & b : number
+>b : number
+
+var rh8 = b & b;
+>rh8 : number
+>b & b : number
+>b : number
+>b : number
+
+// operator ^
+var ri1 = a ^ a;
+>ri1 : number
+>a ^ a : number
+>a : any
+>a : any
+
+var ri2 = a ^ b;
+>ri2 : number
+>a ^ b : number
+>a : any
+>b : number
+
+var ri3 = a ^ 0;
+>ri3 : number
+>a ^ 0 : number
+>a : any
+
+var ri4 = 0 ^ a;
+>ri4 : number
+>0 ^ a : number
+>a : any
+
+var ri5 = 0 ^ 0;
+>ri5 : number
+>0 ^ 0 : number
+
+var ri6 = b ^ 0;
+>ri6 : number
+>b ^ 0 : number
+>b : number
+
+var ri7 = 0 ^ b;
+>ri7 : number
+>0 ^ b : number
+>b : number
+
+var ri8 = b ^ b;
+>ri8 : number
+>b ^ b : number
+>b : number
+>b : number
+
+// operator |
+var rj1 = a | a;
+>rj1 : number
+>a | a : number
+>a : any
+>a : any
+
+var rj2 = a | b;
+>rj2 : number
+>a | b : number
+>a : any
+>b : number
+
+var rj3 = a | 0;
+>rj3 : number
+>a | 0 : number
+>a : any
+
+var rj4 = 0 | a;
+>rj4 : number
+>0 | a : number
+>a : any
+
+var rj5 = 0 | 0;
+>rj5 : number
+>0 | 0 : number
+
+var rj6 = b | 0;
+>rj6 : number
+>b | 0 : number
+>b : number
+
+var rj7 = 0 | b;
+>rj7 : number
+>0 | b : number
+>b : number
+
+var rj8 = b | b;
+>rj8 : number
+>b | b : number
+>b : number
+>b : number
+

tests/baselines/reference/arithmeticOperatorWithEnum.types

@@ -0,0 +1,893 @@
+=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithEnum.ts ===
+// operands of an enum type are treated as having the primitive type Number.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+var c: E;
+>c : E
+>E : E
+
+// operator *
+var ra1 = c * a;
+>ra1 : number
+>c * a : number
+>c : E
+>a : any
+
+var ra2 = c * b;
+>ra2 : number
+>c * b : number
+>c : E
+>b : number
+
+var ra3 = c * c;
+>ra3 : number
+>c * c : number
+>c : E
+>c : E
+
+var ra4 = a * c;
+>ra4 : number
+>a * c : number
+>a : any
+>c : E
+
+var ra5 = b * c;
+>ra5 : number
+>b * c : number
+>b : number
+>c : E
+
+var ra6 = E.a * a;
+>ra6 : number
+>E.a * a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var ra7 = E.a * b;
+>ra7 : number
+>E.a * b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var ra8 = E.a * E.b;
+>ra8 : number
+>E.a * E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var ra9 = E.a * 1;
+>ra9 : number
+>E.a * 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var ra10 = a * E.b;
+>ra10 : number
+>a * E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var ra11 = b * E.b;
+>ra11 : number
+>b * E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var ra12 = 1 * E.b;
+>ra12 : number
+>1 * E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator /
+var rb1 = c / a;
+>rb1 : number
+>c / a : number
+>c : E
+>a : any
+
+var rb2 = c / b;
+>rb2 : number
+>c / b : number
+>c : E
+>b : number
+
+var rb3 = c / c;
+>rb3 : number
+>c / c : number
+>c : E
+>c : E
+
+var rb4 = a / c;
+>rb4 : number
+>a / c : number
+>a : any
+>c : E
+
+var rb5 = b / c;
+>rb5 : number
+>b / c : number
+>b : number
+>c : E
+
+var rb6 = E.a / a;
+>rb6 : number
+>E.a / a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rb7 = E.a / b;
+>rb7 : number
+>E.a / b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rb8 = E.a / E.b;
+>rb8 : number
+>E.a / E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rb9 = E.a / 1;
+>rb9 : number
+>E.a / 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rb10 = a / E.b;
+>rb10 : number
+>a / E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rb11 = b / E.b;
+>rb11 : number
+>b / E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rb12 = 1 / E.b;
+>rb12 : number
+>1 / E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator %
+var rc1 = c % a;
+>rc1 : number
+>c % a : number
+>c : E
+>a : any
+
+var rc2 = c % b;
+>rc2 : number
+>c % b : number
+>c : E
+>b : number
+
+var rc3 = c % c;
+>rc3 : number
+>c % c : number
+>c : E
+>c : E
+
+var rc4 = a % c;
+>rc4 : number
+>a % c : number
+>a : any
+>c : E
+
+var rc5 = b % c;
+>rc5 : number
+>b % c : number
+>b : number
+>c : E
+
+var rc6 = E.a % a;
+>rc6 : number
+>E.a % a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rc7 = E.a % b;
+>rc7 : number
+>E.a % b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rc8 = E.a % E.b;
+>rc8 : number
+>E.a % E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rc9 = E.a % 1;
+>rc9 : number
+>E.a % 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rc10 = a % E.b;
+>rc10 : number
+>a % E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rc11 = b % E.b;
+>rc11 : number
+>b % E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rc12 = 1 % E.b;
+>rc12 : number
+>1 % E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator -
+var rd1 = c - a;
+>rd1 : number
+>c - a : number
+>c : E
+>a : any
+
+var rd2 = c - b;
+>rd2 : number
+>c - b : number
+>c : E
+>b : number
+
+var rd3 = c - c;
+>rd3 : number
+>c - c : number
+>c : E
+>c : E
+
+var rd4 = a - c;
+>rd4 : number
+>a - c : number
+>a : any
+>c : E
+
+var rd5 = b - c;
+>rd5 : number
+>b - c : number
+>b : number
+>c : E
+
+var rd6 = E.a - a;
+>rd6 : number
+>E.a - a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rd7 = E.a - b;
+>rd7 : number
+>E.a - b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rd8 = E.a - E.b;
+>rd8 : number
+>E.a - E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rd9 = E.a - 1;
+>rd9 : number
+>E.a - 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rd10 = a - E.b;
+>rd10 : number
+>a - E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rd11 = b - E.b;
+>rd11 : number
+>b - E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rd12 = 1 - E.b;
+>rd12 : number
+>1 - E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator <<
+var re1 = c << a;
+>re1 : number
+>c << a : number
+>c : E
+>a : any
+
+var re2 = c << b;
+>re2 : number
+>c << b : number
+>c : E
+>b : number
+
+var re3 = c << c;
+>re3 : number
+>c << c : number
+>c : E
+>c : E
+
+var re4 = a << c;
+>re4 : number
+>a << c : number
+>a : any
+>c : E
+
+var re5 = b << c;
+>re5 : number
+>b << c : number
+>b : number
+>c : E
+
+var re6 = E.a << a;
+>re6 : number
+>E.a << a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var re7 = E.a << b;
+>re7 : number
+>E.a << b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var re8 = E.a << E.b;
+>re8 : number
+>E.a << E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var re9 = E.a << 1;
+>re9 : number
+>E.a << 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var re10 = a << E.b;
+>re10 : number
+>a << E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var re11 = b << E.b;
+>re11 : number
+>b << E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var re12 = 1 << E.b;
+>re12 : number
+>1 << E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator >>
+var rf1 = c >> a;
+>rf1 : number
+>c >> a : number
+>c : E
+>a : any
+
+var rf2 = c >> b;
+>rf2 : number
+>c >> b : number
+>c : E
+>b : number
+
+var rf3 = c >> c;
+>rf3 : number
+>c >> c : number
+>c : E
+>c : E
+
+var rf4 = a >> c;
+>rf4 : number
+>a >> c : number
+>a : any
+>c : E
+
+var rf5 = b >> c;
+>rf5 : number
+>b >> c : number
+>b : number
+>c : E
+
+var rf6 = E.a >> a;
+>rf6 : number
+>E.a >> a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rf7 = E.a >> b;
+>rf7 : number
+>E.a >> b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rf8 = E.a >> E.b;
+>rf8 : number
+>E.a >> E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rf9 = E.a >> 1;
+>rf9 : number
+>E.a >> 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rf10 = a >> E.b;
+>rf10 : number
+>a >> E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rf11 = b >> E.b;
+>rf11 : number
+>b >> E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rf12 = 1 >> E.b;
+>rf12 : number
+>1 >> E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator >>>
+var rg1 = c >>> a;
+>rg1 : number
+>c >>> a : number
+>c : E
+>a : any
+
+var rg2 = c >>> b;
+>rg2 : number
+>c >>> b : number
+>c : E
+>b : number
+
+var rg3 = c >>> c;
+>rg3 : number
+>c >>> c : number
+>c : E
+>c : E
+
+var rg4 = a >>> c;
+>rg4 : number
+>a >>> c : number
+>a : any
+>c : E
+
+var rg5 = b >>> c;
+>rg5 : number
+>b >>> c : number
+>b : number
+>c : E
+
+var rg6 = E.a >>> a;
+>rg6 : number
+>E.a >>> a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rg7 = E.a >>> b;
+>rg7 : number
+>E.a >>> b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rg8 = E.a >>> E.b;
+>rg8 : number
+>E.a >>> E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rg9 = E.a >>> 1;
+>rg9 : number
+>E.a >>> 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rg10 = a >>> E.b;
+>rg10 : number
+>a >>> E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rg11 = b >>> E.b;
+>rg11 : number
+>b >>> E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rg12 = 1 >>> E.b;
+>rg12 : number
+>1 >>> E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator &
+var rh1 = c & a;
+>rh1 : number
+>c & a : number
+>c : E
+>a : any
+
+var rh2 = c & b;
+>rh2 : number
+>c & b : number
+>c : E
+>b : number
+
+var rh3 = c & c;
+>rh3 : number
+>c & c : number
+>c : E
+>c : E
+
+var rh4 = a & c;
+>rh4 : number
+>a & c : number
+>a : any
+>c : E
+
+var rh5 = b & c;
+>rh5 : number
+>b & c : number
+>b : number
+>c : E
+
+var rh6 = E.a & a;
+>rh6 : number
+>E.a & a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rh7 = E.a & b;
+>rh7 : number
+>E.a & b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rh8 = E.a & E.b;
+>rh8 : number
+>E.a & E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rh9 = E.a & 1;
+>rh9 : number
+>E.a & 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rh10 = a & E.b;
+>rh10 : number
+>a & E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rh11 = b & E.b;
+>rh11 : number
+>b & E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rh12 = 1 & E.b;
+>rh12 : number
+>1 & E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator ^
+var ri1 = c ^ a;
+>ri1 : number
+>c ^ a : number
+>c : E
+>a : any
+
+var ri2 = c ^ b;
+>ri2 : number
+>c ^ b : number
+>c : E
+>b : number
+
+var ri3 = c ^ c;
+>ri3 : number
+>c ^ c : number
+>c : E
+>c : E
+
+var ri4 = a ^ c;
+>ri4 : number
+>a ^ c : number
+>a : any
+>c : E
+
+var ri5 = b ^ c;
+>ri5 : number
+>b ^ c : number
+>b : number
+>c : E
+
+var ri6 = E.a ^ a;
+>ri6 : number
+>E.a ^ a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var ri7 = E.a ^ b;
+>ri7 : number
+>E.a ^ b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var ri8 = E.a ^ E.b;
+>ri8 : number
+>E.a ^ E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var ri9 = E.a ^ 1;
+>ri9 : number
+>E.a ^ 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var ri10 = a ^ E.b;
+>ri10 : number
+>a ^ E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var ri11 = b ^ E.b;
+>ri11 : number
+>b ^ E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var ri12 = 1 ^ E.b;
+>ri12 : number
+>1 ^ E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator |
+var rj1 = c | a;
+>rj1 : number
+>c | a : number
+>c : E
+>a : any
+
+var rj2 = c | b;
+>rj2 : number
+>c | b : number
+>c : E
+>b : number
+
+var rj3 = c | c;
+>rj3 : number
+>c | c : number
+>c : E
+>c : E
+
+var rj4 = a | c;
+>rj4 : number
+>a | c : number
+>a : any
+>c : E
+
+var rj5 = b | c;
+>rj5 : number
+>b | c : number
+>b : number
+>c : E
+
+var rj6 = E.a | a;
+>rj6 : number
+>E.a | a : number
+>E.a : E
+>E : typeof E
+>a : E
+>a : any
+
+var rj7 = E.a | b;
+>rj7 : number
+>E.a | b : number
+>E.a : E
+>E : typeof E
+>a : E
+>b : number
+
+var rj8 = E.a | E.b;
+>rj8 : number
+>E.a | E.b : number
+>E.a : E
+>E : typeof E
+>a : E
+>E.b : E
+>E : typeof E
+>b : E
+
+var rj9 = E.a | 1;
+>rj9 : number
+>E.a | 1 : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rj10 = a | E.b;
+>rj10 : number
+>a | E.b : number
+>a : any
+>E.b : E
+>E : typeof E
+>b : E
+
+var rj11 = b | E.b;
+>rj11 : number
+>b | E.b : number
+>b : number
+>E.b : E
+>E : typeof E
+>b : E
+
+var rj12 = 1 | E.b;
+>rj12 : number
+>1 | E.b : number
+>E.b : E
+>E : typeof E
+>b : E
+

tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.types

@@ -0,0 +1,450 @@
+=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithNullValueAndValidOperands.ts ===
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+// operator *
+var ra1 = null * a;
+>ra1 : number
+>null * a : number
+>a : any
+
+var ra2 = null * b;
+>ra2 : number
+>null * b : number
+>b : number
+
+var ra3 = null * 1;
+>ra3 : number
+>null * 1 : number
+
+var ra4 = null * E.a;
+>ra4 : number
+>null * E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var ra5 = a * null;
+>ra5 : number
+>a * null : number
+>a : any
+
+var ra6 = b * null;
+>ra6 : number
+>b * null : number
+>b : number
+
+var ra7 = 0 * null;
+>ra7 : number
+>0 * null : number
+
+var ra8 = E.b * null;
+>ra8 : number
+>E.b * null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator /
+var rb1 = null / a;
+>rb1 : number
+>null / a : number
+>a : any
+
+var rb2 = null / b;
+>rb2 : number
+>null / b : number
+>b : number
+
+var rb3 = null / 1;
+>rb3 : number
+>null / 1 : number
+
+var rb4 = null / E.a;
+>rb4 : number
+>null / E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rb5 = a / null;
+>rb5 : number
+>a / null : number
+>a : any
+
+var rb6 = b / null;
+>rb6 : number
+>b / null : number
+>b : number
+
+var rb7 = 0 / null;
+>rb7 : number
+>0 / null : number
+
+var rb8 = E.b / null;
+>rb8 : number
+>E.b / null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator %
+var rc1 = null % a;
+>rc1 : number
+>null % a : number
+>a : any
+
+var rc2 = null % b;
+>rc2 : number
+>null % b : number
+>b : number
+
+var rc3 = null % 1;
+>rc3 : number
+>null % 1 : number
+
+var rc4 = null % E.a;
+>rc4 : number
+>null % E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rc5 = a % null;
+>rc5 : number
+>a % null : number
+>a : any
+
+var rc6 = b % null;
+>rc6 : number
+>b % null : number
+>b : number
+
+var rc7 = 0 % null;
+>rc7 : number
+>0 % null : number
+
+var rc8 = E.b % null;
+>rc8 : number
+>E.b % null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator -
+var rd1 = null - a;
+>rd1 : number
+>null - a : number
+>a : any
+
+var rd2 = null - b;
+>rd2 : number
+>null - b : number
+>b : number
+
+var rd3 = null - 1;
+>rd3 : number
+>null - 1 : number
+
+var rd4 = null - E.a;
+>rd4 : number
+>null - E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rd5 = a - null;
+>rd5 : number
+>a - null : number
+>a : any
+
+var rd6 = b - null;
+>rd6 : number
+>b - null : number
+>b : number
+
+var rd7 = 0 - null;
+>rd7 : number
+>0 - null : number
+
+var rd8 = E.b - null;
+>rd8 : number
+>E.b - null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator <<
+var re1 = null << a;
+>re1 : number
+>null << a : number
+>a : any
+
+var re2 = null << b;
+>re2 : number
+>null << b : number
+>b : number
+
+var re3 = null << 1;
+>re3 : number
+>null << 1 : number
+
+var re4 = null << E.a;
+>re4 : number
+>null << E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var re5 = a << null;
+>re5 : number
+>a << null : number
+>a : any
+
+var re6 = b << null;
+>re6 : number
+>b << null : number
+>b : number
+
+var re7 = 0 << null;
+>re7 : number
+>0 << null : number
+
+var re8 = E.b << null;
+>re8 : number
+>E.b << null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator >>
+var rf1 = null >> a;
+>rf1 : number
+>null >> a : number
+>a : any
+
+var rf2 = null >> b;
+>rf2 : number
+>null >> b : number
+>b : number
+
+var rf3 = null >> 1;
+>rf3 : number
+>null >> 1 : number
+
+var rf4 = null >> E.a;
+>rf4 : number
+>null >> E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rf5 = a >> null;
+>rf5 : number
+>a >> null : number
+>a : any
+
+var rf6 = b >> null;
+>rf6 : number
+>b >> null : number
+>b : number
+
+var rf7 = 0 >> null;
+>rf7 : number
+>0 >> null : number
+
+var rf8 = E.b >> null;
+>rf8 : number
+>E.b >> null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator >>>
+var rg1 = null >>> a;
+>rg1 : number
+>null >>> a : number
+>a : any
+
+var rg2 = null >>> b;
+>rg2 : number
+>null >>> b : number
+>b : number
+
+var rg3 = null >>> 1;
+>rg3 : number
+>null >>> 1 : number
+
+var rg4 = null >>> E.a;
+>rg4 : number
+>null >>> E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rg5 = a >>> null;
+>rg5 : number
+>a >>> null : number
+>a : any
+
+var rg6 = b >>> null;
+>rg6 : number
+>b >>> null : number
+>b : number
+
+var rg7 = 0 >>> null;
+>rg7 : number
+>0 >>> null : number
+
+var rg8 = E.b >>> null;
+>rg8 : number
+>E.b >>> null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator &
+var rh1 = null & a;
+>rh1 : number
+>null & a : number
+>a : any
+
+var rh2 = null & b;
+>rh2 : number
+>null & b : number
+>b : number
+
+var rh3 = null & 1;
+>rh3 : number
+>null & 1 : number
+
+var rh4 = null & E.a;
+>rh4 : number
+>null & E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rh5 = a & null;
+>rh5 : number
+>a & null : number
+>a : any
+
+var rh6 = b & null;
+>rh6 : number
+>b & null : number
+>b : number
+
+var rh7 = 0 & null;
+>rh7 : number
+>0 & null : number
+
+var rh8 = E.b & null;
+>rh8 : number
+>E.b & null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator ^
+var ri1 = null ^ a;
+>ri1 : number
+>null ^ a : number
+>a : any
+
+var ri2 = null ^ b;
+>ri2 : number
+>null ^ b : number
+>b : number
+
+var ri3 = null ^ 1;
+>ri3 : number
+>null ^ 1 : number
+
+var ri4 = null ^ E.a;
+>ri4 : number
+>null ^ E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var ri5 = a ^ null;
+>ri5 : number
+>a ^ null : number
+>a : any
+
+var ri6 = b ^ null;
+>ri6 : number
+>b ^ null : number
+>b : number
+
+var ri7 = 0 ^ null;
+>ri7 : number
+>0 ^ null : number
+
+var ri8 = E.b ^ null;
+>ri8 : number
+>E.b ^ null : number
+>E.b : E
+>E : typeof E
+>b : E
+
+// operator |
+var rj1 = null | a;
+>rj1 : number
+>null | a : number
+>a : any
+
+var rj2 = null | b;
+>rj2 : number
+>null | b : number
+>b : number
+
+var rj3 = null | 1;
+>rj3 : number
+>null | 1 : number
+
+var rj4 = null | E.a;
+>rj4 : number
+>null | E.a : number
+>E.a : E
+>E : typeof E
+>a : E
+
+var rj5 = a | null;
+>rj5 : number
+>a | null : number
+>a : any
+
+var rj6 = b | null;
+>rj6 : number
+>b | null : number
+>b : number
+
+var rj7 = 0 | null;
+>rj7 : number
+>0 | null : number
+
+var rj8 = E.b | null;
+>rj8 : number
+>E.b | null : number
+>E.b : E
+>E : typeof E
+>b : E
+

tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.types

@@ -0,0 +1,530 @@
+=== tests/cases/conformance/expressions/binaryOperators/arithmeticOperator/arithmeticOperatorWithUndefinedValueAndValidOperands.ts ===
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
+
+enum E {
+>E : E
+
+    a,
+>a : E
+
+    b
+>b : E
+}
+
+var a: any;
+>a : any
+
+var b: number;
+>b : number
+
+// operator *
+var ra1 = undefined * a;
+>ra1 : number
+>undefined * a : number
+>undefined : undefined
+>a : any
+
+var ra2 = undefined * b;
+>ra2 : number
+>undefined * b : number
+>undefined : undefined
+>b : number
+
+var ra3 = undefined * 1;
+>ra3 : number
+>undefined * 1 : number
+>undefined : undefined
+
+var ra4 = undefined * E.a;
+>ra4 : number
+>undefined * E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var ra5 = a * undefined;
+>ra5 : number
+>a * undefined : number
+>a : any
+>undefined : undefined
+
+var ra6 = b * undefined;
+>ra6 : number
+>b * undefined : number
+>b : number
+>undefined : undefined
+
+var ra7 = 0 * undefined;
+>ra7 : number
+>0 * undefined : number
+>undefined : undefined
+
+var ra8 = E.b * undefined;
+>ra8 : number
+>E.b * undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator /
+var rb1 = undefined / a;
+>rb1 : number
+>undefined / a : number
+>undefined : undefined
+>a : any
+
+var rb2 = undefined / b;
+>rb2 : number
+>undefined / b : number
+>undefined : undefined
+>b : number
+
+var rb3 = undefined / 1;
+>rb3 : number
+>undefined / 1 : number
+>undefined : undefined
+
+var rb4 = undefined / E.a;
+>rb4 : number
+>undefined / E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rb5 = a / undefined;
+>rb5 : number
+>a / undefined : number
+>a : any
+>undefined : undefined
+
+var rb6 = b / undefined;
+>rb6 : number
+>b / undefined : number
+>b : number
+>undefined : undefined
+
+var rb7 = 0 / undefined;
+>rb7 : number
+>0 / undefined : number
+>undefined : undefined
+
+var rb8 = E.b / undefined;
+>rb8 : number
+>E.b / undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator %
+var rc1 = undefined % a;
+>rc1 : number
+>undefined % a : number
+>undefined : undefined
+>a : any
+
+var rc2 = undefined % b;
+>rc2 : number
+>undefined % b : number
+>undefined : undefined
+>b : number
+
+var rc3 = undefined % 1;
+>rc3 : number
+>undefined % 1 : number
+>undefined : undefined
+
+var rc4 = undefined % E.a;
+>rc4 : number
+>undefined % E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rc5 = a % undefined;
+>rc5 : number
+>a % undefined : number
+>a : any
+>undefined : undefined
+
+var rc6 = b % undefined;
+>rc6 : number
+>b % undefined : number
+>b : number
+>undefined : undefined
+
+var rc7 = 0 % undefined;
+>rc7 : number
+>0 % undefined : number
+>undefined : undefined
+
+var rc8 = E.b % undefined;
+>rc8 : number
+>E.b % undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator -
+var rd1 = undefined - a;
+>rd1 : number
+>undefined - a : number
+>undefined : undefined
+>a : any
+
+var rd2 = undefined - b;
+>rd2 : number
+>undefined - b : number
+>undefined : undefined
+>b : number
+
+var rd3 = undefined - 1;
+>rd3 : number
+>undefined - 1 : number
+>undefined : undefined
+
+var rd4 = undefined - E.a;
+>rd4 : number
+>undefined - E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rd5 = a - undefined;
+>rd5 : number
+>a - undefined : number
+>a : any
+>undefined : undefined
+
+var rd6 = b - undefined;
+>rd6 : number
+>b - undefined : number
+>b : number
+>undefined : undefined
+
+var rd7 = 0 - undefined;
+>rd7 : number
+>0 - undefined : number
+>undefined : undefined
+
+var rd8 = E.b - undefined;
+>rd8 : number
+>E.b - undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator <<
+var re1 = undefined << a;
+>re1 : number
+>undefined << a : number
+>undefined : undefined
+>a : any
+
+var re2 = undefined << b;
+>re2 : number
+>undefined << b : number
+>undefined : undefined
+>b : number
+
+var re3 = undefined << 1;
+>re3 : number
+>undefined << 1 : number
+>undefined : undefined
+
+var re4 = undefined << E.a;
+>re4 : number
+>undefined << E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var re5 = a << undefined;
+>re5 : number
+>a << undefined : number
+>a : any
+>undefined : undefined
+
+var re6 = b << undefined;
+>re6 : number
+>b << undefined : number
+>b : number
+>undefined : undefined
+
+var re7 = 0 << undefined;
+>re7 : number
+>0 << undefined : number
+>undefined : undefined
+
+var re8 = E.b << undefined;
+>re8 : number
+>E.b << undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator >>
+var rf1 = undefined >> a;
+>rf1 : number
+>undefined >> a : number
+>undefined : undefined
+>a : any
+
+var rf2 = undefined >> b;
+>rf2 : number
+>undefined >> b : number
+>undefined : undefined
+>b : number
+
+var rf3 = undefined >> 1;
+>rf3 : number
+>undefined >> 1 : number
+>undefined : undefined
+
+var rf4 = undefined >> E.a;
+>rf4 : number
+>undefined >> E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rf5 = a >> undefined;
+>rf5 : number
+>a >> undefined : number
+>a : any
+>undefined : undefined
+
+var rf6 = b >> undefined;
+>rf6 : number
+>b >> undefined : number
+>b : number
+>undefined : undefined
+
+var rf7 = 0 >> undefined;
+>rf7 : number
+>0 >> undefined : number
+>undefined : undefined
+
+var rf8 = E.b >> undefined;
+>rf8 : number
+>E.b >> undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator >>>
+var rg1 = undefined >>> a;
+>rg1 : number
+>undefined >>> a : number
+>undefined : undefined
+>a : any
+
+var rg2 = undefined >>> b;
+>rg2 : number
+>undefined >>> b : number
+>undefined : undefined
+>b : number
+
+var rg3 = undefined >>> 1;
+>rg3 : number
+>undefined >>> 1 : number
+>undefined : undefined
+
+var rg4 = undefined >>> E.a;
+>rg4 : number
+>undefined >>> E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rg5 = a >>> undefined;
+>rg5 : number
+>a >>> undefined : number
+>a : any
+>undefined : undefined
+
+var rg6 = b >>> undefined;
+>rg6 : number
+>b >>> undefined : number
+>b : number
+>undefined : undefined
+
+var rg7 = 0 >>> undefined;
+>rg7 : number
+>0 >>> undefined : number
+>undefined : undefined
+
+var rg8 = E.b >>> undefined;
+>rg8 : number
+>E.b >>> undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator &
+var rh1 = undefined & a;
+>rh1 : number
+>undefined & a : number
+>undefined : undefined
+>a : any
+
+var rh2 = undefined & b;
+>rh2 : number
+>undefined & b : number
+>undefined : undefined
+>b : number
+
+var rh3 = undefined & 1;
+>rh3 : number
+>undefined & 1 : number
+>undefined : undefined
+
+var rh4 = undefined & E.a;
+>rh4 : number
+>undefined & E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rh5 = a & undefined;
+>rh5 : number
+>a & undefined : number
+>a : any
+>undefined : undefined
+
+var rh6 = b & undefined;
+>rh6 : number
+>b & undefined : number
+>b : number
+>undefined : undefined
+
+var rh7 = 0 & undefined;
+>rh7 : number
+>0 & undefined : number
+>undefined : undefined
+
+var rh8 = E.b & undefined;
+>rh8 : number
+>E.b & undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator ^
+var ri1 = undefined ^ a;
+>ri1 : number
+>undefined ^ a : number
+>undefined : undefined
+>a : any
+
+var ri2 = undefined ^ b;
+>ri2 : number
+>undefined ^ b : number
+>undefined : undefined
+>b : number
+
+var ri3 = undefined ^ 1;
+>ri3 : number
+>undefined ^ 1 : number
+>undefined : undefined
+
+var ri4 = undefined ^ E.a;
+>ri4 : number
+>undefined ^ E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var ri5 = a ^ undefined;
+>ri5 : number
+>a ^ undefined : number
+>a : any
+>undefined : undefined
+
+var ri6 = b ^ undefined;
+>ri6 : number
+>b ^ undefined : number
+>b : number
+>undefined : undefined
+
+var ri7 = 0 ^ undefined;
+>ri7 : number
+>0 ^ undefined : number
+>undefined : undefined
+
+var ri8 = E.b ^ undefined;
+>ri8 : number
+>E.b ^ undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+
+// operator |
+var rj1 = undefined | a;
+>rj1 : number
+>undefined | a : number
+>undefined : undefined
+>a : any
+
+var rj2 = undefined | b;
+>rj2 : number
+>undefined | b : number
+>undefined : undefined
+>b : number
+
+var rj3 = undefined | 1;
+>rj3 : number
+>undefined | 1 : number
+>undefined : undefined
+
+var rj4 = undefined | E.a;
+>rj4 : number
+>undefined | E.a : number
+>undefined : undefined
+>E.a : E
+>E : typeof E
+>a : E
+
+var rj5 = a | undefined;
+>rj5 : number
+>a | undefined : number
+>a : any
+>undefined : undefined
+
+var rj6 = b | undefined;
+>rj6 : number
+>b | undefined : number
+>b : number
+>undefined : undefined
+
+var rj7 = 0 | undefined;
+>rj7 : number
+>0 | undefined : number
+>undefined : undefined
+
+var rj8 = E.b | undefined;
+>rj8 : number
+>E.b | undefined : number
+>E.b : E
+>E : typeof E
+>b : E
+>undefined : undefined
+

tests/baselines/reference/arrayAssignmentTest6.types

@@ -0,0 +1,52 @@
+=== tests/cases/compiler/arrayAssignmentTest6.ts ===
+module Test {
+>Test : typeof Test
+
+    interface IState {
+>IState : IState
+    }
+    interface IToken {
+>IToken : IToken
+
+        startIndex: number;
+>startIndex : number
+    }
+    interface ILineTokens {
+>ILineTokens : ILineTokens
+
+        tokens: IToken[];
+>tokens : IToken[]
+>IToken : IToken
+
+        endState: IState;
+>endState : IState
+>IState : IState
+    }
+    interface IMode {
+>IMode : IMode
+
+        tokenize(line:string, state:IState, includeStates:boolean):ILineTokens;
+>tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
+>line : string
+>state : IState
+>IState : IState
+>includeStates : boolean
+>ILineTokens : ILineTokens
+    }
+    export class Bug implements IMode {
+>Bug : Bug
+>IMode : IMode
+
+        public tokenize(line:string, tokens:IToken[], includeStates:boolean):ILineTokens {
+>tokenize : (line: string, tokens: IToken[], includeStates: boolean) => ILineTokens
+>line : string
+>tokens : IToken[]
+>IToken : IToken
+>includeStates : boolean
+>ILineTokens : ILineTokens
+
+            return null;
+        }
+    }    
+}
+

tests/baselines/reference/arrayAugment.types

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/arrayAugment.ts ===
+interface Array<T> {
+>Array : T[]
+>T : T
+
+    split: (parts: number) => T[][];
+>split : (parts: number) => T[][]
+>parts : number
+>T : T
+}
+
+var x = [''];
+>x : string[]
+>[''] : string[]
+
+var y = x.split(4);
+>y : string[][]
+>x.split(4) : string[][]
+>x.split : (parts: number) => string[][]
+>x : string[]
+>split : (parts: number) => string[][]
+
+var y: string[][]; // Expect no error here
+>y : string[][]
+

tests/baselines/reference/arrayBestCommonTypes.types

@@ -0,0 +1,327 @@
+=== tests/cases/compiler/arrayBestCommonTypes.ts ===
+interface iface { }
+>iface : iface
+
+class base implements iface { }
+>base : base
+>iface : iface
+
+class base2 implements iface { }
+>base2 : base2
+>iface : iface
+
+class derived extends base { }
+>derived : derived
+>base : base
+
+
+class f {
+>f : f
+
+    public voidIfAny(x: boolean, y?: boolean): number;
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : boolean
+>y : boolean
+
+    public voidIfAny(x: string, y?: boolean): number;
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : string
+>y : boolean
+
+    public voidIfAny(x: number, y?: boolean): number;
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : number
+>y : boolean
+
+    public voidIfAny(x: any, y =false): any { return null; }
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : any
+>y : boolean
+    
+    public x() {
+>x : () => void
+
+        <number>(this.voidIfAny([4, 2][0]));
+><number>(this.voidIfAny([4, 2][0])) : number
+>(this.voidIfAny([4, 2][0])) : number
+>this.voidIfAny([4, 2][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[4, 2][0] : number
+>[4, 2] : number[]
+
+        <number>(this.voidIfAny([4, 2, undefined][0]));
+><number>(this.voidIfAny([4, 2, undefined][0])) : number
+>(this.voidIfAny([4, 2, undefined][0])) : number
+>this.voidIfAny([4, 2, undefined][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[4, 2, undefined][0] : number
+>[4, 2, undefined] : number[]
+>undefined : undefined
+
+        <number>(this.voidIfAny([undefined, 2, 4][0]));
+><number>(this.voidIfAny([undefined, 2, 4][0])) : number
+>(this.voidIfAny([undefined, 2, 4][0])) : number
+>this.voidIfAny([undefined, 2, 4][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, 2, 4][0] : number
+>[undefined, 2, 4] : number[]
+>undefined : undefined
+
+        <number>(this.voidIfAny([null, 2, 4][0]));
+><number>(this.voidIfAny([null, 2, 4][0])) : number
+>(this.voidIfAny([null, 2, 4][0])) : number
+>this.voidIfAny([null, 2, 4][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[null, 2, 4][0] : number
+>[null, 2, 4] : number[]
+
+        <number>(this.voidIfAny([2, 4, null][0]));
+><number>(this.voidIfAny([2, 4, null][0])) : number
+>(this.voidIfAny([2, 4, null][0])) : number
+>this.voidIfAny([2, 4, null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[2, 4, null][0] : number
+>[2, 4, null] : number[]
+
+        <number>(this.voidIfAny([undefined, 4, null][0]));
+><number>(this.voidIfAny([undefined, 4, null][0])) : number
+>(this.voidIfAny([undefined, 4, null][0])) : number
+>this.voidIfAny([undefined, 4, null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, 4, null][0] : number
+>[undefined, 4, null] : number[]
+>undefined : undefined
+
+        <number>(this.voidIfAny(['', "q"][0]));
+><number>(this.voidIfAny(['', "q"][0])) : number
+>(this.voidIfAny(['', "q"][0])) : number
+>this.voidIfAny(['', "q"][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>['', "q"][0] : string
+>['', "q"] : string[]
+
+        <number>(this.voidIfAny(['', "q", undefined][0]));
+><number>(this.voidIfAny(['', "q", undefined][0])) : number
+>(this.voidIfAny(['', "q", undefined][0])) : number
+>this.voidIfAny(['', "q", undefined][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>['', "q", undefined][0] : string
+>['', "q", undefined] : string[]
+>undefined : undefined
+
+        <number>(this.voidIfAny([undefined, "q", ''][0]));
+><number>(this.voidIfAny([undefined, "q", ''][0])) : number
+>(this.voidIfAny([undefined, "q", ''][0])) : number
+>this.voidIfAny([undefined, "q", ''][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, "q", ''][0] : string
+>[undefined, "q", ''] : string[]
+>undefined : undefined
+
+        <number>(this.voidIfAny([null, "q", ''][0]));
+><number>(this.voidIfAny([null, "q", ''][0])) : number
+>(this.voidIfAny([null, "q", ''][0])) : number
+>this.voidIfAny([null, "q", ''][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[null, "q", ''][0] : string
+>[null, "q", ''] : string[]
+
+        <number>(this.voidIfAny(["q", '', null][0]));
+><number>(this.voidIfAny(["q", '', null][0])) : number
+>(this.voidIfAny(["q", '', null][0])) : number
+>this.voidIfAny(["q", '', null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>["q", '', null][0] : string
+>["q", '', null] : string[]
+
+        <number>(this.voidIfAny([undefined, '', null][0]));
+><number>(this.voidIfAny([undefined, '', null][0])) : number
+>(this.voidIfAny([undefined, '', null][0])) : number
+>this.voidIfAny([undefined, '', null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, '', null][0] : string
+>[undefined, '', null] : string[]
+>undefined : undefined
+
+        <number>(this.voidIfAny([[3,4],[null]][0][0]));
+><number>(this.voidIfAny([[3,4],[null]][0][0])) : number
+>(this.voidIfAny([[3,4],[null]][0][0])) : number
+>this.voidIfAny([[3,4],[null]][0][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[[3,4],[null]][0][0] : number
+>[[3,4],[null]][0] : number[]
+>[[3,4],[null]] : number[][]
+>[3,4] : number[]
+>[null] : null[]
+        
+        
+        var t1: { x: number; y: base; }[] = [ { x: 7, y: new derived() }, { x: 5, y: new base() } ];
+>t1 : { x: number; y: base; }[]
+>x : number
+>y : base
+>base : base
+>[ { x: 7, y: new derived() }, { x: 5, y: new base() } ] : { x: number; y: base; }[]
+>{ x: 7, y: new derived() } : { x: number; y: derived; }
+>x : number
+>y : derived
+>new derived() : derived
+>derived : typeof derived
+>{ x: 5, y: new base() } : { x: number; y: base; }
+>x : number
+>y : base
+>new base() : base
+>base : typeof base
+
+        var t2: { x: boolean; y: base; }[] = [ { x: true, y: new derived() }, { x: false, y: new base() } ];
+>t2 : { x: boolean; y: base; }[]
+>x : boolean
+>y : base
+>base : base
+>[ { x: true, y: new derived() }, { x: false, y: new base() } ] : { x: boolean; y: base; }[]
+>{ x: true, y: new derived() } : { x: boolean; y: derived; }
+>x : boolean
+>y : derived
+>new derived() : derived
+>derived : typeof derived
+>{ x: false, y: new base() } : { x: boolean; y: base; }
+>x : boolean
+>y : base
+>new base() : base
+>base : typeof base
+
+        var t3: { x: string; y: base; }[] = [ { x: undefined, y: new base() }, { x: '', y: new derived() } ];
+>t3 : { x: string; y: base; }[]
+>x : string
+>y : base
+>base : base
+>[ { x: undefined, y: new base() }, { x: '', y: new derived() } ] : { x: string; y: base; }[]
+>{ x: undefined, y: new base() } : { x: undefined; y: base; }
+>x : any
+>undefined : undefined
+>y : base
+>new base() : base
+>base : typeof base
+>{ x: '', y: new derived() } : { x: string; y: derived; }
+>x : string
+>y : derived
+>new derived() : derived
+>derived : typeof derived
+
+        var anyObj: any = null;
+>anyObj : any
+
+        // Order matters here so test all the variants
+        var a1 = [ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ];
+>a1 : { x: any; y: string; }[]
+>[ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ] : { x: any; y: string; }[]
+>{x: 0, y: 'a'} : { x: number; y: string; }
+>x : number
+>y : string
+>{x: 'a', y: 'a'} : { x: string; y: string; }
+>x : string
+>y : string
+>{x: anyObj, y: 'a'} : { x: any; y: string; }
+>x : any
+>anyObj : anyObj
+>y : string
+
+        var a2 = [ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ];
+>a2 : { x: any; y: string; }[]
+>[ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ] : { x: any; y: string; }[]
+>{x: anyObj, y: 'a'} : { x: any; y: string; }
+>x : any
+>anyObj : anyObj
+>y : string
+>{x: 0, y: 'a'} : { x: number; y: string; }
+>x : number
+>y : string
+>{x: 'a', y: 'a'} : { x: string; y: string; }
+>x : string
+>y : string
+
+        var a3 = [ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ];
+>a3 : { x: any; y: string; }[]
+>[ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ] : { x: any; y: string; }[]
+>{x: 0, y: 'a'} : { x: number; y: string; }
+>x : number
+>y : string
+>{x: anyObj, y: 'a'} : { x: any; y: string; }
+>x : any
+>anyObj : anyObj
+>y : string
+>{x: 'a', y: 'a'} : { x: string; y: string; }
+>x : string
+>y : string
+        
+        var ifaceObj: iface = null;
+>ifaceObj : iface
+>iface : iface
+
+        var baseObj = new base();
+>baseObj : base
+>new base() : base
+>base : typeof base
+
+        var base2Obj = new base2();
+>base2Obj : base2
+>new base2() : base2
+>base2 : typeof base2
+
+        var b1 = [ baseObj, base2Obj, ifaceObj ];
+>b1 : base[]
+>[ baseObj, base2Obj, ifaceObj ] : base[]
+>baseObj : base
+>base2Obj : base2
+>ifaceObj : iface
+
+        var b2 = [ base2Obj, baseObj, ifaceObj ];
+>b2 : base2[]
+>[ base2Obj, baseObj, ifaceObj ] : base2[]
+>base2Obj : base2
+>baseObj : base
+>ifaceObj : iface
+
+        var b3 = [ baseObj, ifaceObj, base2Obj ];
+>b3 : base[]
+>[ baseObj, ifaceObj, base2Obj ] : base[]
+>baseObj : base
+>ifaceObj : iface
+>base2Obj : base2
+
+        var b4 = [ ifaceObj, baseObj, base2Obj ];
+>b4 : iface[]
+>[ ifaceObj, baseObj, base2Obj ] : iface[]
+>ifaceObj : iface
+>baseObj : base
+>base2Obj : base2
+    }
+}
+
+
+

tests/baselines/reference/arrayConcat2.types

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/arrayConcat2.ts ===
+var a: string[] = [];
+>a : string[]
+>[] : string[]
+
+a.concat("hello", 'world');
+>a.concat("hello", 'world') : string[]
+>a.concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
+>a : string[]
+>concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
+
+a.concat('Hello');
+>a.concat('Hello') : string[]
+>a.concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
+>a : string[]
+>concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
+
+var b = new Array<string>();
+>b : string[]
+>new Array<string>() : string[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+
+b.concat('hello');
+>b.concat('hello') : string[]
+>b.concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
+>b : string[]
+>concat : { <U extends string[]>(...items: U[]): string[]; (...items: string[]): string[]; }
+

tests/baselines/reference/arrayConcatMap.types

@@ -0,0 +1,26 @@
+=== tests/cases/compiler/arrayConcatMap.ts ===
+var x = [].concat([{ a: 1 }], [{ a: 2 }])
+>x : any[]
+>[].concat([{ a: 1 }], [{ a: 2 }])
+          .map(b => b.a) : any[]
+>[].concat([{ a: 1 }], [{ a: 2 }])
+          .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
+>[].concat : { <U extends any[]>(...items: U[]): any[]; (...items: any[]): any[]; }
+>[] : undefined[]
+>concat : { <U extends any[]>(...items: U[]): any[]; (...items: any[]): any[]; }
+>[{ a: 1 }] : { a: number; }[]
+>{ a: 1 } : { a: number; }
+>a : number
+>[{ a: 2 }] : { a: number; }[]
+>{ a: 2 } : { a: number; }
+>a : number
+
+          .map(b => b.a);
+>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
+>b => b.a : (b: any) => any
+>b : any
+>b.a : any
+>b : any
+>a : any
+

tests/baselines/reference/arrayConstructors1.types

@@ -0,0 +1,43 @@
+=== tests/cases/compiler/arrayConstructors1.ts ===
+var x: string[];
+>x : string[]
+
+x = new Array(1);
+>x = new Array(1) : any[]
+>x : string[]
+>new Array(1) : any[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+
+x = new Array('hi', 'bye'); 
+>x = new Array('hi', 'bye') : string[]
+>x : string[]
+>new Array('hi', 'bye') : string[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+
+x = new Array<string>('hi', 'bye');
+>x = new Array<string>('hi', 'bye') : string[]
+>x : string[]
+>new Array<string>('hi', 'bye') : string[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+
+var y: number[];
+>y : number[]
+
+y = new Array(1);
+>y = new Array(1) : any[]
+>y : number[]
+>new Array(1) : any[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+
+y = new Array(1,2);
+>y = new Array(1,2) : number[]
+>y : number[]
+>new Array(1,2) : number[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+
+y = new Array<number>(1, 2);
+>y = new Array<number>(1, 2) : number[]
+>y : number[]
+>new Array<number>(1, 2) : number[]
+>Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T>(...items: T[]): T[]; new (arrayLength?: number): any[]; new <T>(arrayLength: number): T[]; new <T>(...items: T[]): T[]; isArray(arg: any): boolean; prototype: any[]; }
+